analyze

Analyze — Phase 1 Entry Point (v2)

Launches the phased code-analysis pipeline on top of the GitNexus knowledge graph.

Usage

/analyze                         # analyze the whole repo (scope=**/*)
/analyze src/**/*.ts             # glob scope
/analyze **/*.h, **/*.cpp        # multiple globs, comma-separated
/analyze authentication flow     # natural-language scope → mcp__gitnexus__query

Initialization Gate (hard-require verification)

Before any analysis work, run these checks in this order. Abort with a single consolidated error if any fail.

1. gitnexus CLI: command -v gitnexus. If absent: "GitNexus is required. Install: npm i -g gitnexus".

2. GitNexus index for this repo: invoke MCP tool mcp__gitnexus__list_repos. If this repo not listed: "GitNexus has no index. Run: npx gitnexus analyze".

3. GitNexus index freshness: compare indexed lastCommit vs git rev-parse HEAD. If > 10 commits behind, prompt the user: "Index is N commits behind HEAD. Reindex now? [y/N]". Do not auto-run.

4. codeanalyzer CLI: command -v codeanalyzer.

5. Language detection: invoke code-analysis:detect-language for the scope → confirmed primary language.

6. Language pack load (required): load code-analysis-{lang}:strategy skill. If not installed: "Language pack code-analysis-{lang} not installed." — abort.

7. Framework discovery (generic): Enumerate all installed skills matching code-analysis-*:strategy. For each such strategy, read its framework_detection YAML block (absent for language packs). A framework strategy matches if:

   • framework_detection.requires_language equals the confirmed language (or is absent), AND
   • at least framework_detection.min_signatures signatures match against the current repo state.

   Signature kinds:

   • file_exists: glob pattern — check via Glob or find
   • source_macro: list of macros — grep source files (use mcp__gitnexus__cypher for existence query: MATCH (n) WHERE n.source CONTAINS macro)
   • source_include: list of include patterns — similar grep check

   For EVERY matching framework strategy, load its skill. Multiple frameworks can match simultaneously. If none match: no framework pack loaded — pure language analysis proceeds.

8. static_tools verification (aggregated): for each loaded strategy path, invoke: codeanalyzer list-tools --strategy <path> --no-verify --json > /tmp/<strategy>.json This emits every declared tool without exiting non-zero on missing ones.

   Then locally check each tool.command's first token via shutil.which (or shell command -v):

   • Collect a missing_tools list with {strategy, phase, tool_name, binary} rows for every non-resolvable binary.

   If missing_tools is non-empty: emit ONE consolidated error block listing every missing item + its install hint (if declared), then abort. Do NOT retry per-issue.

   If empty: proceed to Step 9.

9. Initialize phase-state via MCP: invoke mcp__codeanalyzer__initialize_phase_state with { language, framework: <first-matched-framework-or-null>, report_language }. If multiple frameworks match, framework is a comma-joined string (e.g., "unreal,qt"); downstream consumers should split on comma.

Scope Resolution

If the argument is a glob pattern (contains * or /) or empty, use directly (default **/*).

Otherwise treat it as natural language:

• Invoke mcp__gitnexus__query with {query: "<arg>", limit: 50}.
• If 0 results: prompt user to refine.
• If ≥1 results: extract file paths from the results → de-dup → use as scope. Persist the resolved scope to .codeanalyzer/config.json under scope_files.

First-Run Config Prompt

On first invocation (no .codeanalyzer/config.json present):

• Ask: exclude patterns (glob list, default []), report language (ko/en, default ko).
• Write to .codeanalyzer/config.json with these + current scope.

Pipeline Invocation

After the gate passes, delegate to the structure-analyzer agent. Pass: resolved scope, strategy paths, GitNexus repo id.

Error Messages

All aborts emit a single block with every problem plus the specific install commands — no retry-per-issue loops.