mikeng-io/agent-skills/deep-explorer

[skills-root]/context/SKILL.md
[skills-root]/preflight/SKILL.md
[skills-root]/domain-registry/README.md

⚠ Missing required skills for deep-explorer:
 
  {missing-skill}
    Expected: {skills-root}/{missing-skill}/SKILL.md
 
Install the missing skill(s):
  git clone https://github.com/mikeng-io/agent-skills /tmp/agent-skills
  cp -r /tmp/agent-skills/skills/{missing-skill} {skills-root}/
 
Or install the full suite at once:
  cp -r /tmp/agent-skills/skills/ {skills-root}/

context_report:
  artifact_type: ""  # code | financial | marketing | creative | research | mixed
  domains: []        # matched domain names from domain-registry
  routing: ""        # routing recommendation (informational for explorer)
  confidence: ""     # high | medium | low

scope_clarification:
  artifact: ""       # repository or directory to explore
  intent: "explore"
  domains: []        # focus domains for exploration (supplements context_report.domains)
  constraints: []    # specific areas to prioritize or exclude
  confidence: ""     # high | medium

working_scope:
  artifact: ""            # repository or directory to explore
  domains: []             # from context_report, supplemented by preflight
  constraints: []         # areas to prioritize or exclude
  context_summary: ""     # combined description for explorer agent prompts

# Check if Git repository
if ! git rev-parse --is-inside-work-tree 2>/dev/null; then
  # Git not available — proceed with full filesystem exploration
  EXPLORATION_TYPE="full"
  GIT_AVAILABLE=false
else
  # Verify Git is functional (has at least one commit)
  if ! git rev-parse HEAD 2>/dev/null; then
    EXPLORATION_TYPE="full"
    GIT_AVAILABLE=false
  else
    GIT_AVAILABLE=true
  fi
fi

# Check for previous exploration
LAST_EXPLORATION=".outputs/exploration/latest-exploration.json"
 
if [ -f "$LAST_EXPLORATION" ]; then
  # Previous exploration exists
  EXPLORATION_TYPE="delta"
  BASELINE_COMMIT=$(jq -r '.baseline_commit' "$LAST_EXPLORATION")
  BASELINE_TIMESTAMP=$(jq -r '.baseline_timestamp' "$LAST_EXPLORATION")
else
  # No previous exploration
  EXPLORATION_TYPE="full"
  BASELINE_COMMIT=$(git rev-parse HEAD)
  BASELINE_TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
fi

# Get baseline commit from last exploration
BASELINE=$(jq -r '.baseline_commit' .outputs/exploration/latest-exploration.json)
CURRENT=$(git rev-parse HEAD)
 
# Find committed changes since baseline
git diff --name-status $BASELINE $CURRENT > committed_changes.txt
 
# Categorize changes
MODIFIED=$(git diff --name-only --diff-filter=M $BASELINE $CURRENT)
ADDED=$(git diff --name-only --diff-filter=A $BASELINE $CURRENT)
DELETED=$(git diff --name-only --diff-filter=D $BASELINE $CURRENT)
RENAMED=$(git diff --name-only --diff-filter=R $BASELINE $CURRENT)

# Working directory changes (modified but not staged)
UNCOMMITTED_MODIFIED=$(git diff --name-only HEAD)
 
# Staged changes (committed to index but not committed)
STAGED=$(git diff --name-only --cached)
 
# Untracked files (new files not in Git)
UNTRACKED=$(git ls-files --others --exclude-standard)

changes_detected:
  committed:
    status: stable
    files:
      - modified: [list from git diff]
      - added: [list from git diff]
      - deleted: [list from git diff]
      - renamed: [list from git diff]
 
  uncommitted:
    status: work_in_progress
    files:
      - modified: [list from git diff HEAD]
      - staged: [list from git diff --cached]
      - untracked: [list from git ls-files --others]
 
total_changes: <count>
exploration_scope: [list of unique files to re-explore]

tasks:
  # Wave 1: Foundation (must run first)
  - id: structure
    description: "Analyze directory structure"
    agent: "structure-explorer"
    depends_on: []
 
  # Wave 2: Technology and dependency analysis (need structure)
  - id: technology
    description: "Identify technologies and frameworks"
    agent: "technology-explorer"
    depends_on: [structure]
 
  - id: dependencies
    description: "Map dependencies and imports"
    agent: "dependency-explorer"
    depends_on: [structure]
 
  # Wave 3: Architecture and workflows (need structure + tech/deps)
  - id: architecture
    description: "Analyze architectural patterns"
    agent: "architecture-explorer"
    depends_on: [structure, technology]
 
  - id: workflows
    description: "Trace workflows and data flows"
    agent: "workflow-explorer"
    depends_on: [structure, dependencies]
 
execution:
  mode: dag-orchestrated
  waves:
    wave_1: [structure]                     # 1 task
    wave_2: [technology, dependencies]      # 2 tasks in parallel
    wave_3: [architecture, workflows]       # 2 tasks in parallel
  capability: high

Capability: high
 
You are a STRUCTURE EXPLORER. Analyze the repository structure and organization.
 
## Your Task
1. Map directory hierarchy using Glob and ls
2. Count files by type (extensions)
3. Identify organizational patterns
4. Find configuration files
5. Analyze naming conventions
 
## Output Format (JSON)
{
  "agent": "structure-explorer",
  "directory_structure": {
    "total_directories": 24,
    "total_files": 188,
    "hierarchy": "..."
  },
  "file_distribution": {
    "typescript": 145,
    "javascript": 23,
    "json": 12,
    "markdown": 8
  },
  "organizational_patterns": [
    "Feature-based organization",
    "Separation of concerns",
    "Test files colocated with source"
  ],
  "configuration_files": [
    "package.json",
    "tsconfig.json",
    ".eslintrc.js",
    "docker-compose.yml"
  ]
}

Capability: high
 
You are a TECHNOLOGY EXPLORER. Inventory the technology stack.
 
## Your Task
1. Detect languages from file extensions
2. Identify frameworks from package.json, requirements.txt, etc.
3. Find build tools (Makefile, scripts, etc.)
4. Extract dependencies and versions
 
## Output Format (JSON)
{
  "agent": "technology-explorer",
  "languages": [
    {"name": "TypeScript", "file_count": 145, "primary": true},
    {"name": "JavaScript", "file_count": 23, "primary": false}
  ],
  "frameworks": [
    {"name": "Express.js", "version": "^4.18.0", "purpose": "web server"},
    {"name": "React", "version": "^18.2.0", "purpose": "frontend"}
  ],
  "build_tools": ["npm", "webpack", "docker"],
  "dependencies": {
    "production": {...},
    "development": {...}
  }
}

Capability: high
 
You are an ARCHITECTURE EXPLORER. Identify architectural patterns and structure.
 
## Your Task
1. Analyze project structure (MVC, microservices, etc.)
2. Identify module organization
3. Detect design patterns used
4. Assess separation of concerns
 
## Output Format (JSON)
{
  "agent": "architecture-explorer",
  "project_structure": "Layered architecture",
  "layers": [
    {"name": "API Layer", "location": "src/api/"},
    {"name": "Business Logic", "location": "src/services/"},
    {"name": "Data Layer", "location": "src/models/"}
  ],
  "design_patterns": [
    {"pattern": "Factory", "location": "src/factories/"},
    {"pattern": "Repository", "location": "src/repositories/"},
    {"pattern": "Dependency Injection", "implementation": "constructor-based"}
  ],
  "separation_quality": "high"
}

Capability: high
 
You are a WORKFLOW EXPLORER. Trace code flows and entry points.
 
## Your Task
1. Find entry points (main files)
2. Trace key workflows
3. Map data flow patterns
4. Identify integration points