@veewo/gitnexus 1.5.6 → 1.5.8

package/dist/mcp/local/runtime-claim-rule-registry.test.js

@@ -1,24 +1,14 @@
 import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
 import { test } from 'vitest';
-import { RuleRegistryLoadError, loadRuleRegistry } from './runtime-claim-rule-registry.js';
-test('loads active runtime claim rules from project catalog', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.2.3',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v1.yaml'), [
+import { RuleRegistryLoadError, parseRuleYaml } from './runtime-claim-rule-registry.js';
+test('RuleRegistryLoadError has code and context', () => {
+    const err = new RuleRegistryLoadError('rule_catalog_missing', 'Catalog not found', { repoPath: '/tmp/repo' });
+    assert.ok(err instanceof RuleRegistryLoadError);
+    assert.equal(err.code, 'rule_catalog_missing');
+    assert.match(String(err.message || ''), /Catalog not found/);
+});
+test('parseRuleYaml parses basic fields', () => {
+    const yaml = [
         'id: demo.reload.rule.v1',
         'version: 1.2.3',
         'trigger_family: reload',
@@ -33,106 +23,37 @@ test('loads active runtime claim rules from project catalog', async () => {
         'non_guarantees:',
         '  - no_runtime_execution',
         'next_action: gitnexus query "reload"',
-    ].join('\n'), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        assert.equal(registry.activeRules[0].id, 'demo.reload.rule.v1');
-        assert.equal(registry.activeRules[0].version, '1.2.3');
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_catalog_missing when target repo has no catalog (no ancestor fallback)', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const workspaceRoot = path.join(tempRoot, 'workspace');
-    const nestedCwd = path.join(workspaceRoot, 'packages', 'app');
-    const rulesRoot = path.join(workspaceRoot, '.gitnexus', 'rules');
-    const catalogPath = path.join(rulesRoot, 'catalog.json');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.mkdir(nestedCwd, { recursive: true });
-    await fs.writeFile(catalogPath, JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.2.3',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v1.yaml'), ['id: demo.reload.rule.v1', 'version: 1.2.3', 'trigger_family: reload'].join('\n'), 'utf-8');
-    const originalCwd = process.cwd();
-    process.chdir(nestedCwd);
-    try {
-        await assert.rejects(() => loadRuleRegistry(path.join(tempRoot, 'does-not-exist')), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_catalog_missing');
-            assert.match(String(error.message || ''), /catalog not found/i);
-            return true;
-        });
-    }
-    finally {
-        process.chdir(originalCwd);
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_catalog_missing when rulesRoot exists but catalog.json is missing', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_catalog_missing');
-            return true;
-        });
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('throws rule_file_missing when catalog entry points to missing yaml file', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v1',
-                version: '1.0.0',
-                file: 'approved/demo.reload.rule.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), (error) => {
-            assert.ok(error instanceof RuleRegistryLoadError);
-            assert.equal(error.code, 'rule_file_missing');
-            assert.match(String(error.message || ''), /rule file not found/i);
-            return true;
-        });
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
+        'match:',
+        '  trigger_tokens:',
+        '    - reload',
+        'closure:',
+        '  required_hops:',
+        '    - resource',
+        'claims:',
+        '  guarantees:',
+        '    - reload_chain_closed',
+        '  non_guarantees:',
+        '    - no_runtime_execution',
+        '  next_action: gitnexus query "reload"',
+        'topology:',
+        '  - hop: resource',
+        '    from:',
+        '      entity: resource',
+        '    to:',
+        '      entity: script',
+        '    edge:',
+        '      kind: binds_script',
+    ].join('\n');
+    const rule = parseRuleYaml(yaml, 'test.yaml');
+    assert.equal(rule.id, 'demo.reload.rule.v1');
+    assert.equal(rule.version, '1.2.3');
+    assert.equal(rule.trigger_family, 'reload');
+    assert.deepEqual(rule.resource_types, ['asset']);
+    assert.deepEqual(rule.host_base_type, ['ReloadBase']);
+    assert.equal(rule.file_path, 'test.yaml');
 });
-test('parses scalar/list values with spaces, quotes, and escapes without truncation', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.scalar-parser.v1',
-                version: '1.0.0',
-                file: 'approved/demo.scalar-parser.v1.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.scalar-parser.v1.yaml'), [
+test('parseRuleYaml parses scalar/list values with spaces, quotes, and escapes', () => {
+    const yaml = [
         'id: demo.scalar-parser.v1',
         'version: 1.0.0',
         'trigger_family: reload',
@@ -149,100 +70,32 @@ test('parses scalar/list values with spaces, quotes, and escapes without truncat
         '  - "double-quote \\"inside\\""',
         "  - 'single-quote ''inside'''",
         'next_action: node gitnexus/dist/cli/index.js query --runtime-chain-verify on-demand "Reload NEON.Game.Graph.Nodes.Reloads"',
-    ].join('\n'), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        const rule = registry.activeRules[0];
-        assert.equal(rule.id, 'demo.scalar-parser.v1');
-        assert.deepEqual(rule.resource_types, ['asset ref', 'prefab ref']);
-        assert.deepEqual(rule.guarantees, ['guarantee with spaces']);
-        assert.deepEqual(rule.non_guarantees, ['double-quote "inside"', "single-quote 'inside'"]);
-        assert.equal(rule.next_action, 'node gitnexus/dist/cli/index.js query --runtime-chain-verify on-demand "Reload NEON.Game.Graph.Nodes.Reloads"');
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('rejects rule yaml when topology/closure/claims are missing', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const rulesRoot = path.join(repoPath, '.gitnexus', 'rules');
-    await fs.mkdir(path.join(rulesRoot, 'approved'), { recursive: true });
-    await fs.writeFile(path.join(rulesRoot, 'catalog.json'), JSON.stringify({
-        rules: [
-            {
-                id: 'demo.reload.rule.v2',
-                version: '2.0.0',
-                file: 'approved/demo.reload.rule.v2.yaml',
-            },
-        ],
-    }), 'utf-8');
-    await fs.writeFile(path.join(rulesRoot, 'approved', 'demo.reload.rule.v2.yaml'), [
-        'id: demo.reload.rule.v2',
-        'version: 2.0.0',
-        'trigger_family: reload',
-        'resource_types:',
-        '  - asset',
-        'host_base_type:',
-        '  - ReloadBase',
-        'required_hops:',
-        '  - resource',
-        'guarantees:',
-        '  - reload_chain_closed',
-        'non_guarantees:',
-        '  - no_runtime_execution_guarantee',
-    ].join('\n'), 'utf-8');
-    try {
-        await assert.rejects(() => loadRuleRegistry(repoPath), /topology|closure|claims/i);
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
-});
-test('loads v2 verification bundle from explicit compiled path without catalog fallback', async () => {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gitnexus-runtime-claim-rules-'));
-    const repoPath = path.join(tempRoot, 'repo');
-    const compiledRoot = path.join(repoPath, '.gitnexus', 'rules', 'compiled');
-    await fs.mkdir(compiledRoot, { recursive: true });
-    await fs.writeFile(path.join(compiledRoot, 'verification_rules.v2.json'), JSON.stringify({
-        bundle_version: '2.0.0',
-        family: 'verification_rules',
-        generated_at: new Date().toISOString(),
-        rules: [
-            {
-                id: 'demo.bundle.rule.v2',
-                version: '2.0.0',
-                trigger_family: 'reload',
-                resource_types: ['asset'],
-                host_base_type: ['ReloadBase'],
-                required_hops: ['resource', 'code_runtime'],
-                guarantees: ['reload_chain_closed'],
-                non_guarantees: ['no_runtime_execution'],
-                next_action: 'gitnexus query "reload"',
-                file_path: '.gitnexus/rules/compiled/verification_rules.v2.json',
-                match: { trigger_tokens: ['reload'] },
-                topology: [
-                    { hop: 'resource', from: { entity: 'resource' }, to: { entity: 'script' }, edge: { kind: 'binds_script' } },
-                ],
-                closure: {
-                    required_hops: ['resource', 'code_runtime'],
-                    failure_map: { missing_evidence: 'rule_matched_but_evidence_missing' },
-                },
-                claims: {
-                    guarantees: ['reload_chain_closed'],
-                    non_guarantees: ['no_runtime_execution'],
-                    next_action: 'gitnexus query "reload"',
-                },
-            },
-        ],
-    }, null, 2), 'utf-8');
-    try {
-        const registry = await loadRuleRegistry(repoPath);
-        assert.equal(registry.activeRules[0].id, 'demo.bundle.rule.v2');
-        assert.equal(registry.activeRules[0].version, '2.0.0');
-        assert.deepEqual(registry.activeRules[0].required_hops, ['resource', 'code_runtime']);
-    }
-    finally {
-        await fs.rm(tempRoot, { recursive: true, force: true });
-    }
+        'match:',
+        '  trigger_tokens:',
+        '    - reload',
+        'closure:',
+        '  required_hops:',
+        '    - resource',
+        'claims:',
+        '  guarantees:',
+        "    - 'guarantee with spaces'",
+        '  non_guarantees:',
+        '    - "double-quote \\"inside\\""',
+        "    - 'single-quote ''inside'''",
+        '  next_action: query "reload"',
+        'topology:',
+        '  - hop: resource',
+        '    from:',
+        '      entity: resource',
+        '    to:',
+        '      entity: script',
+        '    edge:',
+        '      kind: binds_script',
+    ].join('\n');
+    const rule = parseRuleYaml(yaml, 'scalar.yaml');
+    assert.equal(rule.id, 'demo.scalar-parser.v1');
+    assert.deepEqual(rule.resource_types, ['asset ref', 'prefab ref']);
+    assert.deepEqual(rule.guarantees, ['guarantee with spaces']);
+    assert.deepEqual(rule.non_guarantees, ['double-quote "inside"', "single-quote 'inside'"]);
+    assert.equal(rule.next_action, 'query "reload"');
 });

package/dist/mcp/tools.js

@@ -383,76 +383,6 @@ Output enforces unique-result policy and includes path+line evidence hops.`,
             required: ['target', 'goal'],
         },
     },
-    {
-        name: 'rule_lab_analyze',
-        description: `Analyze one Rule Lab slice and emit anchor-backed candidates.jsonl.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_review_pack',
-        description: `Pack analyzed candidates into review cards with token budget enforcement.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                max_tokens: { type: 'number', description: 'Token budget cap (default: 6000)', default: 6000 },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_curate',
-        description: `Validate human-curated semantic closure input and persist curated artifacts for promotion.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                input_path: { type: 'string', description: 'Absolute or repo-relative path to curation input JSON' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id', 'input_path'],
-        },
-    },
-    {
-        name: 'rule_lab_promote',
-        description: `Promote curated candidates into approved YAML rules and upsert catalog.json entries.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                run_id: { type: 'string', description: 'Rule Lab run id' },
-                slice_id: { type: 'string', description: 'Rule Lab slice id' },
-                version: { type: 'string', description: 'Promoted rule version (default: 1.0.0)', default: '1.0.0' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['run_id', 'slice_id'],
-        },
-    },
-    {
-        name: 'rule_lab_regress',
-        description: `Evaluate Rule Lab precision/coverage gates and optionally persist a regression report.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                precision: { type: 'number', description: 'Observed precision metric' },
-                coverage: { type: 'number', description: 'Observed coverage metric' },
-                probes_path: { type: 'string', description: 'Optional path to a JSON array of regression probes with bucket metadata' },
-                run_id: { type: 'string', description: 'Optional run id for report naming' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
-            },
-            required: ['precision', 'coverage'],
-        },
-    },
     {
         name: 'impact',
         description: `Analyze the blast radius of changing a code symbol.

package/dist/storage/repo-manager.d.ts

@@ -15,6 +15,7 @@ export interface RepoMeta {
         scopeRules?: string[];
         repoAlias?: string;
         embeddings?: boolean;
+        csharpDefineCsproj?: string;
     };
     stats?: {
         files?: number;

package/dist/types/pipeline.d.ts

@@ -2,7 +2,6 @@ import { GraphNode, GraphRelationship, KnowledgeGraph } from '../core/graph/type
 import { CommunityDetectionResult } from '../core/ingestion/community-processor.js';
 import { ProcessDetectionResult } from '../core/ingestion/process-processor.js';
 import type { UnityResourceProcessingResult } from '../core/ingestion/unity-resource-processor.js';
-import type { UnityRuntimeBindingResult } from '../core/ingestion/unity-runtime-binding-rules.js';
 import type { ScopeSelectionDiagnostics } from '../core/ingestion/scope-filter.js';
 export type PipelinePhase = 'idle' | 'extracting' | 'structure' | 'parsing' | 'imports' | 'calls' | 'heritage' | 'communities' | 'processes' | 'enriching' | 'complete' | 'error';
 export interface PipelineProgress {
@@ -40,7 +39,6 @@ export interface PipelineResult {
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
-    unityRuleBindingResult?: UnityRuntimeBindingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
     csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }
@@ -49,7 +47,6 @@ export interface PipelineRuntimeSummary {
     communityResult?: CommunityDetectionResult;
     processResult?: ProcessDetectionResult;
     unityResult?: UnityResourceProcessingResult;
-    unityRuleBindingResult?: UnityRuntimeBindingResult;
     scopeDiagnostics?: ScopeSelectionDiagnostics;
     csharpPreprocDiagnostics?: CSharpPreprocDiagnostics;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veewo/gitnexus",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/skills/gitnexus-cli.md

@@ -60,73 +60,97 @@ $GN analyze
 
 Run from the project root. This parses all source files, builds the knowledge graph, writes it to `.gitnexus/`, and generates CLAUDE.md / AGENTS.md context files.
 
+Analyze options are resolved with two-layer priority: **CLI arguments** > **stored options** in `meta.json.analyzeOptions`. On first run, pass CLI flags; they are persisted automatically for subsequent runs.
+
 | Flag | Effect |
 |------|--------|
 | `--force` | Force full re-index even if up to date |
+| `--no-reuse-options` | Do not reuse stored analyze options from previous index |
 | `--embeddings` | Enable embedding generation (off by default) |
+| `--extensions <list>` | Comma-separated file extensions (e.g. `.cs,.ts`) |
+| `--scope <rules>` | Comma-separated scope path-prefix rules (e.g. `Assets/,Packages/com.veewo.*`) |
+| `--repo-alias <name>` | Override indexed repository name with a stable alias |
+| `--csharp-define-csproj <path>` | Load C# `DefineConstants` from `.csproj` for `#if` normalization |
 | `--skills` | Generate repo-specific skill files from detected communities |
+| `-v, --verbose` | Enable verbose ingestion warnings |
 
-**Two mutually exclusive paths. Choose one per rebuild.**
+**Option persistence:** `--extensions`, `--scope`, `--repo-alias`, `--embeddings`, and `--csharp-define-csproj` are automatically saved to `meta.json.analyzeOptions` after a successful run. On subsequent runs, these stored values are reused unless you pass new CLI flags or use `--no-reuse-options`.
 
-#### Path A: sync-manifest managed (recommended for Unity / monorepo)
+#### Scope rules
 
-If `.gitnexus/sync-manifest.txt` exists, `analyze` **auto-uses** it when you do **not** pass `--scope-prefix` or `--scope-manifest`.
+Scope rules control which files are included in the index. When no scope rules are stored, **all files** in the repo are indexed. Use `--scope` on first run to set scope rules; they are persisted automatically.
+
+**Scope rule semantics:**
+- Each rule is a **path prefix** — `Assets/` matches all files under `Assets/`
+- Trailing `*` is a **wildcard prefix** — `Packages/com.veewo.*` matches `Packages/com.veewo.stat/...`
+- No glob support: `Assets/**/*.cs` will not work
+- Empty scope = full repo scan (all files)
 
 ```bash
-# Unity project with an existing manifest — this is the normal rebuild command
+# Scope to specific directories
+$GN analyze --force --scope "Assets/,Packages/"
+
+# Wildcard scope
+$GN analyze --force --scope "Assets/NEON/Code,Packages/com.veewo.*"
+
+# No --scope = full repo (or reuse stored scope rules)
 $GN analyze --force
 ```
 
-The manifest controls scope rules, extensions, and repo alias. Example:
+#### Unity project recommended parameters
 
-```
-Assets/
-Packages/
-@extensions=.cs,.meta
-@repoAlias=neonspark-core
+Unity projects benefit from a specific combination of parameters to ensure correct C# parsing and optimal scope:
+
+```bash
+# Unity project — first-time index (recommended)
+$GN analyze --force \
+  --extensions ".cs,.meta" \
+  --scope "Assets/,Packages/" \
+  --repo-alias <repo-alias> \
+  --csharp-define-csproj <path-to-Assembly-CSharp.csproj>
+
+# Subsequent rebuilds (all options are reused automatically)
+$GN analyze --force
 ```
 
-- Non-`@` lines = path-prefix scope rules
-- `@extensions=<csv>` = file extension filter
-- `@repoAlias=<name>` = stable repo alias
-- `@embeddings=<true|false>` = embedding toggle
+| Parameter | Recommended value | Why |
+|-----------|------------------|-----|
+| `--extensions` | `.cs,.meta` | C# scripts + Unity `.meta` asset files for resource binding |
+| `--scope` | `Assets/,Packages/` | Limit to Unity project directories; skip `Library/`, `Temp/`, `obj/` |
+| `--csharp-define-csproj` | `path/to/Assembly-CSharp.csproj` | Normalize `#if` / `#elif` conditional compilation using project's `DefineConstants` |
+| `--repo-alias` | e.g. `neonspark-core` | Stable alias for MCP repo lookup regardless of directory name |
 
-**Drift guard:** If you pass `--extensions` / `--repo-alias` / `--embeddings` while a manifest exists, CLI compares them. Use `--sync-manifest-policy` to control: `ask|update|keep|error` (default `ask`; non-TTY requires explicit policy).
+**C# preprocessing detail:** Unity projects commonly use conditional compilation (`#if UNITY_EDITOR`, `#if NEON_DEBUG`, etc.). Without `--csharp-define-csproj`, tree-sitter parses each `#if` branch as-is, often producing incorrect AST for the active branch. The csproj path is persisted and reused automatically after first specification.
 
-**Do not mix Path A and Path B.** Passing `--scope-prefix` or `--extensions` when a manifest exists triggers the drift guard and may error out in non-TTY environments.
+**Scope for large Unity repos:** For repos where only specific packages matter, narrow scope instead of indexing all of `Assets/`:
 
-#### Path B: manual CLI flags (first-time or simple projects)
+```bash
+$GN analyze --force \
+  --scope "Assets/NEON/Code,Packages/com.veewo.*" \
+  --extensions ".cs,.meta" \
+  --repo-alias neonspark-core
+```
 
-Use when no sync-manifest exists:
+#### Other project examples
 
 ```bash
-# Unity project, first-time index
-$GN analyze --force --extensions ".cs,.meta" --scope-prefix Assets/ --repo-alias neonspark-core
+# Generic TypeScript project
+$GN analyze --force --extensions ".ts,.tsx" --repo-alias my-project
 
-# Generic project
-$GN analyze --force --extensions ".ts,.tsx" --scope-prefix src/
+# Subsequent rebuilds (stored options are reused automatically)
+$GN analyze --force
 ```
 
-| Manual flag | Effect |
-|-------------|--------|
-| `--extensions <ext>` | Comma-separated file extensions |
-| `--scope-prefix <prefix>` | Add a path prefix rule (repeatable) |
-| `--scope-manifest <file>` | Read scope rules from a manifest file |
-| `--repo-alias <name>` | Override indexed repository name |
-| `--csharp-define-csproj <path>` | Load C# `DefineConstants` from `.csproj` for `#if` normalization |
-
-**C# preprocessing (Unity):** For projects with heavy conditional compilation, add `--csharp-define-csproj /path/to/Assembly-CSharp.csproj` (neonspark: `/Volumes/Shuttle/projects/neonspark/Assembly-CSharp.csproj`). Without it, C# files are parsed raw and tree-sitter may mishandle `#if` branches.
-
 #### Rebuild recovery — when analyze hangs or crashes
 
 If `analyze --force` hangs (no progress after 5+ minutes) or crashes leaving a corrupted index:
 
 ```bash
-# 1. Clean the corrupted index (preserves sync-manifest.txt)
+# 1. Clean the corrupted index
 $GN clean --force
 
-# 2. Rebuild
-$GN analyze --force
+# 2. Rebuild (re-specify CLI options since meta.json was deleted)
+$GN analyze --force --extensions ".cs,.meta" --repo-alias neonspark-core
 ```
 
 **When to clean before rebuild:**
@@ -145,13 +169,13 @@ $GN status
 
 Shows whether the current repo has a GitNexus index, when it was last updated, and symbol/relationship counts. Use this to check if re-indexing is needed.
 
-### clean — Delete the index (preserves config)
+### clean — Delete the index
 
 ```bash
 $GN clean --force
 ```
 
-Removes the GitNexus index (graph, CSVs, LadybugDB) from `.gitnexus/` while **preserving `sync-manifest.txt`** and other configuration files. Use this to recover from a corrupted index before re-indexing.
+Removes the entire `.gitnexus/` directory (including `meta.json` and all index data). After cleaning, you must re-specify analyze options on the next `analyze` run since stored options are deleted.
 
 | Flag      | Effect                                            |
 | --------- | ------------------------------------------------- |
@@ -237,7 +261,7 @@ $GN unity-ui-trace "Assets/NEON/VeewoUI/Uxml/BarScreen/Patch/PatchItemPreview.ux
 - **"Not inside a git repository"**: Run from a directory inside a git repo
 - **Index is stale after re-analyzing**: Restart Claude Code to reload the MCP server
 - **Embeddings slow**: Omit `--embeddings` (it's off by default) or set `OPENAI_API_KEY` for faster API-based embedding
-- **`analyze --force` hangs or crashes**: Run `$GN clean --force` to remove the corrupted index (sync-manifest is preserved), then `$GN analyze --force` to rebuild. Common corruption signatures: `.gitnexus/csv/` exists but `relations.csv` is missing; `.gitnexus/lbug.wal` exists while `lbug` is only a few KB.
+- **`analyze --force` hangs or crashes**: Run `$GN clean --force` to remove the corrupted index, then `$GN analyze --force` (with your CLI options) to rebuild. Common corruption signatures: `.gitnexus/csv/` exists but `relations.csv` is missing; `.gitnexus/lbug.wal` exists while `lbug` is only a few KB.
 
 ## Runtime-Chain Closure Guard
 

package/vendor/node_modules/node-addon-api/node_addon_api.Makefile

@@ -0,0 +1,6 @@
+# This file is generated by gyp; do not edit.
+
+export builddir_name ?= ./build/../../node_modules/node-addon-api/.
+.PHONY: all
+all:
+	$(MAKE) -C ../../tree-sitter-dart/build node_addon_api_except