ai-code-map 0.0.0-stage → 0.1.0-alpha.3

package/AGENTS.md

@@ -0,0 +1,26 @@
+# Agent instructions
+
+## Code navigation
+
+- Use `ai-code-map` to locate relevant symbols when their source location is unknown.
+- Run commands from the project root.
+- Before using the map, run `pnpm exec ai-code-map check`.
+- If the map is missing or stale (exit code 2), run
+  `pnpm exec ai-code-map scan`.
+- Read the beginning of `.ai/code-map/overview.md` only when broader project
+  structure is needed. Skip it for a focused task with a known area of the code.
+- Find symbols with `pnpm exec ai-code-map find 'search words'`.
+- After `find` identifies a relevant symbol, use `pnpm exec ai-code-map read '<stable-id>'`.
+  This reads current source through the map, with two context lines and at most
+  80 source lines per call. Follow the printed continuation only if needed.
+- Reuse IDs and source already returned. Do not repeat `find` for a known symbol
+  or read its entire file just to see that symbol. Expand to a specific dependency
+  only when an unresolved question requires it.
+- Use `pnpm exec ai-code-map show '<stable-id>'` only to answer an unresolved
+  question about symbol relations. Use an ID returned by `find`; do not call
+  `show` merely to redisplay a symbol whose source location is already known.
+- Do not load entire `manifest.json`, `symbols.jsonl`, or `relations.jsonl`
+  files into context. Select only the records relevant to the task.
+- Source code is the source of truth. Check it before making changes.
+- If the map does not help or a command fails, use regular search with `rg`.
+- The map is optional for a simple edit in a known file.

package/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+## Unreleased
+
+## 2026-11-01
+
+### 0.1.0-alpha.3
+
+- Add bounded `context` / `buildSourceContext` packets with current source, direct symbol links, file-level references, and up to four small outgoing dependencies.
+- Add a reproducible token benchmark with fixed budgets, raw usage accounting, and manual paired quality review; accept recursive map exclusions in search commands.
+- Token savings remain experimental: the latest 12-attempt, three-project comparison saved 0.9% overall and failed two paired quality comparisons. This release does not claim savings above 10% or quality non-degradation.
+
+- Add `map` to check freshness and return the complete structural graph in one call, with short references and grouped relation counts.
+
+- Include bounded direct symbol links and test call sites on the first `read` page, with reusable IDs and omission counts.
+
+- Add map-guided `read` / `readSymbolSource` with bounded source pages, freshness checks, and continuation; update and package agent navigation instructions and a reusable Codex skill.
+
+- Improve multiword symbol search with common plural normalization, name-aware ranking, and explicitly labeled partial matches.
+
+- Add compact text `show` with full source ranges, grouped relations, and explicit omission counts.
+- Preserve verbose output through `show --full` and complete records through `show --json`.
+- Add `find` / `findSymbols` for bounded symbol discovery and typo suggestions on failed `show` selectors.
+
+## 2026-11-01
+
+### 0.1.0-alpha.2
+
+- Release compiler memory after each unit in default scans by using sequential workers.
+- Avoid unused TypeScript JSDoc parsing while preserving JavaScript JSDoc type information.
+- Preserve in-process behavior and full JSDoc for custom analyzers and semantic resolvers.
+- Retain semantic closure, artifact validation, CWD independence, and unchanged-map reuse.
+- Advance the semantic resolver version; maps from the previous version require a rescan.
+
+## 2026-08-06
+
+### 0.1.0
+
+- Initial alpha implementation and documentation baseline.
+- Added CLI commands: `init`, `scan`, `check`, `show`.
+- Added deterministic persisted artifacts:
+  - `manifest.json`
+  - `project.json`
+  - `files.jsonl`
+  - `symbols.jsonl`
+  - `relations.jsonl`
+  - `diagnostics.json`
+  - `overview.md`
+- Added core semantic analyzers:
+  - TypeScript/Node symbols and references
+  - React component/hook/component-relationship facts
+- Added `ai-code-map check` freshness contract with added/modified/deleted/moved reporting.
+- Added programmatic exports for scanning, loading maps, showing symbols, and constructing analyzers.
+- Added CI pipeline and initial package-level documentation set.

package/CONTRIBUTING.md

@@ -0,0 +1,43 @@
+# Contributing
+
+Thank you for improving AI Code Map.
+
+## Development setup
+
+Use `pnpm` for package management:
+
+```bash
+pnpm install
+```
+
+## Typical workflow
+
+1. Create or update docs/tests/fixtures as needed.
+2. Keep outputs deterministic: stable ordering and stable JSON formatting.
+3. Run local checks:
+
+```bash
+pnpm run lint
+pnpm run typecheck
+pnpm run test
+pnpm run build
+```
+
+## Project principles
+
+- Favor static analysis over runtime behavior.
+- Preserve existing behavior and avoid broad rewrites.
+- Keep source snippets out of persisted artifacts unless explicitly introduced and safe.
+- Preserve determinism for existing tests and fixture outputs.
+
+## Documentation scope
+
+This repository documents an alpha workflow first:
+
+- commands: `init`, `scan`, `check`, `show`
+- deterministic map artifacts
+- TS/JS/React compiler-backed analysis
+
+## Working with existing changes
+
+Do not revert unrelated user edits in this worktree. Keep changes narrowly scoped and preserve file ownership boundaries when multiple contributors are involved.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ai-code-map contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,370 @@
-# Temporary Holding Version
+# AI Code Map
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+AI Code Map is a local, deterministic code understanding layer for TypeScript, JavaScript, and React projects. It analyzes source files into stable symbols, relations, and diagnostics so AI coding agents can plan with a compact, trustworthy index before opening many files.
+
+## Key properties (alpha scope)
+
+- **Local-only execution**: scanning reads project files and writes local artifacts; no LLM calls are used during analysis.
+- **Deterministic by design**: identical inputs produce byte-identical artifacts.
+- **Compiler-authoritative**: TypeScript compiler is the trusted semantic layer for symbols, references, imports, and types.
+- **Evidence-backed facts**: relations carry a source range, analyzer, classification, and confidence; source code remains authoritative.
+- **No network/telemetry by default**: no outbound upload is part of a standard scan.
+- **Small CLI**: `init`, `scan`, `check`, `find`, `show`.
+
+## Quick start
+
+```bash
+pnpm install
+pnpm exec ai-code-map init
+pnpm exec ai-code-map scan
+pnpm exec ai-code-map check
+pnpm exec ai-code-map find "calculator"
+pnpm exec ai-code-map show Calculator
+```
+
+### Exit codes
+
+| Command | Success                   | Failure behavior                                           |
+| ------- | ------------------------- | ---------------------------------------------------------- |
+| `init`  | `0`                       | invalid configuration or environment errors -> `1`         |
+| `scan`  | `0`                       | parser errors with `--strict` -> `3`, otherwise `0`        |
+| `check` | `0` when current          | stale map -> `2`, missing map -> `2`                       |
+| `map`   | `0` when current          | stale, missing, or invalid map -> `2`; other errors -> `1` |
+| `show`  | `0`                       | no match -> `1`                                            |
+| `find`  | `0`, including no matches | invalid query or limit -> `1`                              |
+
+## CLI command matrix
+
+All commands share these options:
+
+- `--root <path>`: project root to scan (defaults by searching up to nearest `package.json`)
+- `--config <path>`: config path (absolute or relative to CWD)
+- `--output <path>`: map output directory
+- `--json`: machine-readable output where supported
+
+### `ai-code-map init`
+
+Creates `.ai/code-map/config.json` (or `--output/config.json`) only if missing unless `--force` is set.
+
+### `ai-code-map scan`
+
+Analyzes source files and writes map artifacts to output directory.
+
+- `--strict`: exit code `3` if any diagnostic with `code === "parse-error"` has severity `error`.
+
+### `ai-code-map check`
+
+Compares the persisted `manifest.json` against current state and config:
+
+- source hash set changes (`added|modified|deleted|moved`)
+- framework/schema/parser/analyzer/config version drift
+- schema compatibility
+
+Returns `Current` or `Stale` with machine-readable reasons and change lists.
+
+### `ai-code-map map`
+
+Prints the complete structural map in one call. It checks freshness internally;
+no separate `check` call is needed. If the map is missing, stale, or invalid, it
+returns exit code 2 without printing the graph. Run `scan` to rebuild it.
+
+```bash
+pnpm exec ai-code-map map
+pnpm exec ai-code-map map --json
+```
+
+The output includes every indexed file and symbol, plus every relation endpoint.
+Files, symbols, and other endpoints receive short references (`f1`, `s1`, `e1`)
+used in the relation table. Symbols also show their stable IDs and source lines.
+Use the stable ID with `read`; short references apply only to this output and may
+change after a rescan.
+
+Relations are grouped by source, type, and evidence classification. A target such
+as `s2*3` represents three occurrence records. All classifications are retained,
+including heuristic and derived links; these must not be interpreted as exact
+calls. Source text, signatures, facts, and per-occurrence evidence are excluded.
+Use `show --json` for detailed evidence and `read` for current source.
+
+There is no pagination or silent row limit. The `End of map` marker confirms that
+the CLI reached the end; a calling tool may still truncate a large response.
+The whole map can exceed an agent's output or context limit. One call does not
+guarantee fewer tokens than focused navigation. Redirect to a file when needed:
+
+```bash
+pnpm exec ai-code-map map > /tmp/project-map.txt
+```
+
+### `ai-code-map show <selector>`
+
+Displays indexed symbol(s) by:
+
+- exact stable ID
+- shorthand `kind:name` (aliases: `component`, `hook`, `function`, `class`, `method`, `interface`, `type`, `variable`, `page`, `controller`, `module`)
+- `path` or `path#name`
+- exact symbol name
+
+Default text is compact: up to five symbols, full source ranges, signatures capped at 240
+characters, and up to 12 relation groups across the response. Repeated relations of the same
+direction, type, and endpoint are grouped with occurrence counts. Internal links come first.
+Heuristic/unresolved relations, derived inverse links, containment/export edges, and references
+that duplicate a more specific relation are filtered. Each symbol reports shown/omitted groups
+and filtered record counts. Documentation and facts are available in the full view.
+
+- `--limit <1..50>` changes the total relation-group limit for compact text.
+- `--full` preserves the previous verbose text view.
+- `--json` preserves the complete `ShowResult`, including all relation evidence.
+
+These are row and signature limits, not a token budget. A failed selector suggests up to five
+indexed candidates; it never silently selects a different symbol.
+
+### `ai-code-map find <query>`
+
+Searches indexed symbol names and paths. Quote multiword queries, for example
+`ai-code-map find "manager change"`. Exact names/IDs rank first, followed by prefix/substring,
+word matches, and bounded typo matching. Word matching normalizes common English plurals
+and favors matches in symbol names over paths. Whitespace-separated queries with at least three distinct words
+can also return partial matches: at least two words and half the query must match, including
+one word in the symbol name. These rank below full matches and typo hints. Partial results
+show which normalized terms were unmatched. This is lexical search, not semantic search;
+`read` is not treated as a synonym of `viewed`. For example, `notification mark read` can
+find `markNotificationsAsViewed` through `notification` and `mark`.
+
+Read the selected symbol with `ai-code-map read '<id>'`. Use `show` when symbol relations are needed.
+
+Results include stable IDs usable by `show`, kinds, and full source ranges. The default is ten
+matches; `--limit <1..50>` adjusts this. `--json` returns `{ query, total, truncated, matches }`.
+No matches is a successful empty search. Use `rg` for source text or symbols outside the index.
+
+### `ai-code-map context <query>`
+
+Collects current source for a quoted lexical query or exact symbol ID and its direct
+exact/framework-derived graph neighbors in one call. It checks freshness first;
+missing or stale maps return exit code 2. No model, embeddings, or network is used.
+
+The default selects up to three matches and favors behavior over partial type matches.
+For partial queries, it checks missing query words in the current bodies of up to
+50 lexical candidates. It expands the strongest callable matches when source
+evidence distinguishes them. This lexical ranking does not infer intent or synonyms.
+An exact name or ID takes precedence. Each selected match expands once using the
+bounded navigation rules of `read`; reference-only class neighbors are counted as
+omitted, so a namespace reference does not load every method. Explicit class
+queries remain supported. Source windows include two context lines.
+Up to four incoming file-level call/reference sites are also included, such as
+route registrations outside any function. Files of at most 80 lines are read in
+full; larger files use eight lines on each side of the mapped site. These windows
+share the same budgets and source validation as symbol windows.
+After those windows, remaining budget can include up to four small functions or
+values referenced by direct outgoing neighbors. Their bodies must be at most 80
+lines; calls take priority over references. This extra step does not recurse or
+expand incoming callers, and cannot displace the primary source windows.
+Overlapping and adjacent ranges in the same file are emitted together with original
+line numbers. Shared budgets are 800 source lines and 32,000 source characters
+(including line separators); headers and bounded metadata are additional.
+
+Options: `--seeds <1..5>`, `--max-lines <1..2000>`, `--max-chars <256..64000>`,
+`--json`. Partial lexical matches keep their unmatched terms. Omitted source ranges,
+other search-match count, and omitted navigation entries are explicit. Test call
+sites are hints, not proof of coverage. A packet is a bounded local neighborhood,
+not a claim to contain every dependency or every fact needed for the task.
+
+For example: `ai-code-map context 'notification mark read'`. Reuse the returned
+source and read only a specific missing range or dependency next. The existing
+`find`, `read`, and `show` commands remain available for narrower requests.
+
+### `ai-code-map read <id>`
+
+Reads current source using an exact stable ID returned by `find`. Includes two lines
+of context on each side of the symbol. Output is numbered and limited to 80 source
+lines by default; `--limit <1..200>` changes the page size. Long symbols provide an
+explicit `--offset` continuation within the same window. Reuse what you have already
+read; follow a continuation or another symbol only for an unresolved question.
+
+The first page also lists up to eight direct symbol neighbors and four exact incoming
+call sites in test paths (`*.test.*`, `*.spec.*`, or `__tests__/`). Neighbors include
+reusable IDs, source ranges, direction, relation type, and evidence classification.
+Repeated neighbors are merged. Heuristic and derived inverse relations, containment,
+exports, and unresolved or external endpoints are excluded. Test paths are navigation
+hints, not proof of test coverage. Missing entries do not prove that no tests exist.
+The block stays below 4,000 compact JSON characters and reports eligible entries
+omitted by its limits. Continuation pages do not repeat it. Use `show '<id>'` for
+more relations when needed.
+
+The file must be inside the project root, regular, and match its indexed hash.
+Changed files require `scan` before reading. Source pages over 12,000 characters are
+rejected: reduce `--limit`, or use targeted source search for an oversized single line.
+`--json` includes source, range, truncation, continuation metadata, and first-page
+`navigation`. Source is read
+on demand and is not added to persisted map artifacts. Run `check` before navigation;
+this command validates the selected source file, not every project dependency.
+
+The packaged `AGENTS.md` describes this navigation workflow. A reusable Codex skill
+is included at `skills/ai-code-map/SKILL.md`. Copy the `ai-code-map` folder to your
+Codex skills directory and invoke `$ai-code-map`. It guides combined context retrieval,
+relation lookups, and targeted fallback for unindexed tests; it also supports older
+CLI versions without `read` by using the returned source ranges directly.
+
+## Generated artifacts
+
+The scanner writes these deterministic files under the output directory (default `.ai/code-map`):
+
+- `overview.md` (human view)
+- `manifest.json`
+- `project.json`
+- `files.jsonl`
+- `symbols.jsonl`
+- `relations.jsonl`
+- `diagnostics.json`
+
+`project.json` is a required companion artifact. Loading or reusing a map validates it together with
+the manifest, JSONL records, diagnostics, and their cross-record ownership/count invariants.
+
+See [`docs/artifacts.md`](./docs/artifacts.md) and [`docs/schema.md`](./docs/schema.md) for exact field-level formats.
+
+## Config
+
+Configuration is read from `config.json` and validated via [`config.schema.json`](./config.schema.json). All paths are root-relative (POSIX) in persisted records.
+
+Default include patterns:
+
+```json
+{
+  "include": [
+    "src/**/*",
+    "app/**/*",
+    "pages/**/*",
+    "lib/**/*",
+    "server/**/*",
+    "*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"
+  ]
+}
+```
+
+Default exclusions:
+
+```json
+[
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/.git/**",
+  "**/.ai/**",
+  "**/*.generated.*"
+]
+```
+
+Full config fields are documented in [`docs/schema.md`](./docs/schema.md).
+
+## Programmatic API example
+
+The programmatic surface is exported from the package root:
+
+```ts
+import {
+  initProject,
+  scanProject,
+  loadCodeMap,
+  checkFreshness,
+  showSymbol,
+  createAnalyzer,
+  NextJsAnalyzer,
+  NestJsAnalyzer,
+} from "ai-code-map";
+
+const root = process.cwd();
+
+await initProject({ root });
+const scan = await scanProject({ root });
+console.log(scan.counts, scan.changes, scan.criticalParseErrors);
+
+const map = await loadCodeMap({ root });
+const result = showSymbol(map, "component:UserList");
+console.log(result.matches.map((entry) => entry.symbol.id));
+
+const freshness = await checkFreshness({ root });
+console.log(freshness.current ? "current" : "stale");
+
+const analyzer = createAnalyzer({
+  analyzers: [new NextJsAnalyzer(), new NestJsAnalyzer()],
+});
+await analyzer.scan({ root });
+```
+
+`createAnalyzer` returns a composable scan surface for custom analyzers and parser adapters.
+
+## Stability, evidence, confidence, and freshness
+
+### Stable IDs
+
+- File IDs use `file:<posix-path>`
+- Symbol IDs use stable, path-scoped IDs like `component:src/app/App.tsx#AppShell`
+- Route and external IDs are explicit prefixes (`route:`, `external:`)
+
+IDs are designed to survive unrelated edits when logical identity is unchanged.
+
+### Evidence and confidence
+
+- Evidence includes parser-origin and file/line ranges in symbol relations.
+- Relation origins classify evidence as `exact`, `framework-derived`, `heuristic`, or `derived` and identify the producing analyzer.
+- Relation `confidence` is bounded to `[0, 1]`:
+  - `1` for compiler-exact resolution
+  - lower values when fallback inference is used
+
+### Freshness
+
+Freshness compares:
+
+- manifest/source hashes
+- schema version
+- analyzer and parser versions
+- effective framework selection
+- configuration hash including relevant project metadata
+
+`ai-code-map check` reports actionable reasons and exact change buckets.
+
+## Known limitations
+
+- CLI is intentionally alpha: only `init`, `scan`, `check`, and `show`.
+- No source execution, no dynamic config loading, no project remote ingestion.
+- `show` is a single-symbol query, not a full search/index query language.
+- `Next.js` and `NestJS` analyzers are exported and available programmatically but are **experimental and default-off** in CLI because they are not in the default analyzer list.
+- Tree-sitter/ast-grep is not enabled in production scans. A pinned ast-grep development spike and microbenchmark exist, while TS/JS/React analysis remains compiler-authoritative.
+- Compiler-unit discovery, deterministic file ownership, project references, extended configs, and
+  bounded fallback analysis are implemented. Complex conditional package exports and references
+  outside the selected root remain bounded limitations.
+- No planned Beta/Later capabilities are claimed by default.
+
+## AI-agent instructions (copy/paste)
+
+Use this with your agent context:
+
+### English
+
+Use the Code Map as a navigation index, not as a replacement for source. Start with `ai-code-map init` then `ai-code-map scan`; do not upload map output and do not read every `.ai/code-map` artifact automatically. For each change:
+
+1. Inspect symbols via `ai-code-map show <id|kind:name|name> --json`.
+2. Read only the files and symbols directly connected through relations.
+3. Keep decisions tied to map evidence and confidence; do not assume behavior beyond relation origin lines.
+4. Open and verify the authoritative source before editing.
+5. Before finalizing, run `ai-code-map check` to verify no stale output changes.
+
+### Русский
+
+Используйте Code Map как навигационный индекс, а не замену исходному коду. Выполните `ai-code-map init`, затем `ai-code-map scan`; не отправляйте артефакты наружу и не читайте автоматически все файлы `.ai/code-map`. Для каждого изменения:
+
+1. Смотрите символы через `ai-code-map show <id|kind:name|name> --json`.
+2. Открывайте только файлы и связи, которые действительно относятся к выбранным символам.
+3. Проверяйте решения по доказательствам из артефактов и уровню `confidence`; не делайте предположений без этих данных.
+4. Перед изменением откройте и проверьте исходный код как главный источник истины.
+5. Перед завершением выполните `ai-code-map check`, чтобы убедиться, что карта актуальна.
+
+Architecture decisions and deferred work are recorded in [`docs/architecture/ADR-0001-hybrid-syntax-and-semantics.md`](./docs/architecture/ADR-0001-hybrid-syntax-and-semantics.md) and [`docs/backlog.md`](./docs/backlog.md).
+
+## Contributing and security
+
+See [`CONTRIBUTING.md`](./CONTRIBUTING.md) and [`SECURITY.md`](./SECURITY.md).
+
+## Changelog
+
+See [`CHANGELOG.md`](./CHANGELOG.md).

package/SECURITY.md

@@ -0,0 +1,18 @@
+# Security policy
+
+AI Code Map is designed for local, static analysis and currently has no background telemetry or remote upload in alpha scanning flow.
+
+## Reporting issues
+
+- Review public issues and avoid sharing repository secrets, `.env` values, or private source content.
+- Report vulnerabilities by opening an advisory in the project security channel.
+- For GitHub-based reporting:
+  `https://github.com/example/ai-code-map/security/advisories/new`
+
+## Security boundaries to preserve
+
+- Do not execute scanned project code.
+- Do not follow symlinks outside the resolved project root.
+- Avoid resolving or serializing arbitrary runtime values.
+- Keep path handling root-relative and normalized.
+- Keep source code snippets minimized and only emit explicit, documented evidence fields.

package/config.schema.json

@@ -0,0 +1,130 @@
+{
+  "$defs": {
+    "__schema0": {
+      "const": 1,
+      "default": 1,
+      "type": "number"
+    },
+    "__schema1": {
+      "default": "../..",
+      "minLength": 1,
+      "type": "string"
+    },
+    "__schema10": {
+      "maximum": 64,
+      "minimum": 1,
+      "type": "integer"
+    },
+    "__schema2": {
+      "default": [
+        "src/**/*",
+        "app/**/*",
+        "pages/**/*",
+        "lib/**/*",
+        "server/**/*",
+        "*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"
+      ],
+      "items": {
+        "$ref": "#/$defs/__schema3"
+      },
+      "minItems": 1,
+      "type": "array"
+    },
+    "__schema3": {
+      "minLength": 1,
+      "type": "string"
+    },
+    "__schema4": {
+      "default": [
+        "**/node_modules/**",
+        "**/.next/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/coverage/**",
+        "**/.git/**",
+        "**/.ai/**",
+        "**/*.generated.*"
+      ],
+      "items": {
+        "minLength": 1,
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "__schema5": {
+      "minLength": 1,
+      "type": "string"
+    },
+    "__schema6": {
+      "default": [
+        "auto"
+      ],
+      "items": {
+        "$ref": "#/$defs/__schema7"
+      },
+      "minItems": 1,
+      "type": "array"
+    },
+    "__schema7": {
+      "anyOf": [
+        {
+          "enum": [
+            "typescript",
+            "node",
+            "react",
+            "nextjs",
+            "nestjs"
+          ],
+          "type": "string"
+        },
+        {
+          "const": "auto",
+          "type": "string"
+        }
+      ]
+    },
+    "__schema8": {
+      "default": ".ai/code-map",
+      "minLength": 1,
+      "type": "string"
+    },
+    "__schema9": {
+      "default": false,
+      "type": "boolean"
+    }
+  },
+  "$id": "urn:ai-code-map:config:1",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "properties": {
+    "concurrency": {
+      "$ref": "#/$defs/__schema10"
+    },
+    "exclude": {
+      "$ref": "#/$defs/__schema4"
+    },
+    "frameworks": {
+      "$ref": "#/$defs/__schema6"
+    },
+    "include": {
+      "$ref": "#/$defs/__schema2"
+    },
+    "includePrivateSymbols": {
+      "$ref": "#/$defs/__schema9"
+    },
+    "output": {
+      "$ref": "#/$defs/__schema8"
+    },
+    "root": {
+      "$ref": "#/$defs/__schema1"
+    },
+    "tsconfig": {
+      "$ref": "#/$defs/__schema5"
+    },
+    "version": {
+      "$ref": "#/$defs/__schema0"
+    }
+  },
+  "title": "ai-code-map configuration",
+  "type": "object"
+}

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+declare function runCli(argv?: string[]): Promise<number>;
+
+export { runCli };