project-athena 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.3.0 — 2026-09-30
+
+Performance release: work is now proportional to what changed. On a 20,000-file repository (vs 0.2.1): a `sync --check` with nothing changed takes ~0.42 s instead of 2.9 s, `status` 0.14 s instead of 0.34 s, agent hooks start in ~28 ms instead of 112 ms, and peak memory is 20–52% lower in every scenario. The generated `model.json` is unchanged (golden-tested against the 0.2.1 analyzer). Benchmarks: `npm run bench`.
+
+After upgrading, the first run rebuilds `.athena/state.json` in the new format automatically. If you use the pre-commit hook, run `athena git-hook install` again so it checks staged content.
+
+### Performance
+
+- `athena open` reuses parsed `.athena` artifacts: a new `ProjectSession` loads `model.json`, `graph.json`, `security-scan.json` and `state.json` once and re-reads them only when the file changes (inode, size or mtime). The overview, graph, context, security and `athena security` paths share it, and the graph summary checks for `model.json` with a stat instead of parsing and validating the whole model.
+- The event stream (`/api/events`) coalesces bursts into one write per 250 ms (intermediate activity states collapse to the latest), serializes each event once for all clients, and applies backpressure: a client that stops reading gets nothing more until its socket drains, keeps at most 100 queued events (oldest dropped) plus the latest activity, and then receives a `resync` frame with the number of events it missed. At most 16 event streams are open at once (503 beyond that).
+- `GET /api/sync` no longer includes each proposed document's full diff; the Sync page fetches a diff from the new `GET /api/sync/:doc` only when the document is expanded.
+- `athena event` (run by agent hooks on every tool call) starts about 2.5× faster and uses about 40% less memory (p50 112 ms / 100 MB → ~45 ms / 57 MB on the 20k-file benchmark): it no longer loads commander or any other command's dependencies. All other commands load their code on demand, which also lowers memory for `status`, `review` and `sync`.
+- `athena event` no longer loads zod: the paths it needs moved to a dependency-free module (`src/core/paths.ts`). p50 of 10 on an Apple M-series laptop: ~43 ms / 57 MB → ~26 ms / 49 MB. The startup test now fails if zod reaches the event chunk.
+- The CLI is now built with code splitting: `dist/cli.js` is a small entry that loads chunks from `dist/` as needed.
+- Project graph building is linear in the number of edges (edge de-duplication, import traversal and package lookups no longer rescan everything); 50k import edges now build in about 0.1 s instead of 3.2 s, and 100k in about 0.25 s. Graph output is unchanged. `athena graph --node` and task-context expansion use a per-graph index.
+- Git metadata is collected with concurrent `git` processes, the `git --version` check runs once per process, and history is read once, bounded to the last 180 days / 2,000 commits. The contributor count in `model.json` (`git.contributorCount`) now counts authors in that window instead of the whole history.
+- Nested `.gitignore` matching only consults the path's own ancestor directories instead of every `.gitignore` in the project.
+- Analysis is staged and incremental: a stat-only walk, one content pass in which every new or changed file is read exactly once (hashing and all per-file detector work share the same bytes), then an aggregate stage that builds the model from cached per-file facts. Unchanged files are not read at all. The generated `model.json` is unchanged (guarded by a golden test against the 0.2.1 analyzer).
+- 20,000-file benchmark (Apple M-series, vs 0.2.1): warm `sync --check` 2.9 s → 0.50 s (×5.8), `sync --check` after a one-file change 2.9 s → 0.49 s, cold `init` 3.5 s → 2.3 s; peak memory lower in every scenario (warm sync 195 → 162 MB). 200,000 files: warm `sync --check` 46 s → 4.1 s, cold `init` 51 s → 40 s, peak memory 730 → 589 MB (init).
+- File text is no longer cached without limit during analysis: a 64 MB byte-budgeted LRU serves the rare aggregate-stage lookup, and text is dropped as soon as a file's facts are computed.
+- Sync planning goes through one scheduler per project (`src/services/scheduler.ts`): at most one analysis runs at a time, requests that arrive meanwhile share a single follow-up run, and new file changes can cancel a plan that is still in progress (planning is read-only). The file watcher, the local server (`POST /api/sync/check`, review, re-plans after edits) and the MCP server use it, so concurrent checks no longer start concurrent full analyses; applying a proposal and a full re-analysis from the web UI never interleave with planning.
+- While `athena open` (or another watcher) is running, a plan after file changes re-checks only the paths the watcher reported instead of walking the whole tree (about 265 → 170 ms for a one-file change in the 20k-file benchmark, in-process). It walks the whole tree on the first plan, after a `.gitignore`, `.athena/config.json` or `.git/info/exclude` change, a directory add/delete, a watcher error, when the project contains symbolic links, and at least every 5 minutes.
+- `athena status` (and the server's status, the MCP `get_project_changes` tool) no longer walks the tree: it stats the files in the cached index and asks Git for new files (`git ls-files`, `git status --porcelain=v2 -z`). 254 → ~140 ms on the 20k-file benchmark; ~0.85 s for 200k files. The output is unchanged; it falls back to walking when Git can't give the same answer (no Git or no index, `include` patterns, ignore rules changed since the last analysis, submodules, nested repositories, symlinked directories).
+- The server's status report is cached until the watcher reports a change (with a 30 s safety TTL, instead of a flat 3 s), and concurrent requests share one computation.
+
+### Changed
+
+- **The pre-commit hook checks what is being committed.** New `athena sync --check --staged` compares the `.athena/` knowledge as staged with what Athena generates from the code as staged, so untracked files (a scratch file, a local `.env`) and unstaged edits no longer block a commit, and a staged change reverted in the working tree still counts. It mirrors the index into `.athena/cache/staged/` (gitignored, updated incrementally): files that match the working tree are sparse stand-ins that reuse the last analysis's hashes and the facts cache, so only staged changes are read (20k files, warm: ~0.54 s vs ~0.44 s for the working-tree check). When `athena sync` already wrote a document that isn't staged, the output says which files to `git add`; JSON output has `staged`, `inSync`, `stale` and per-document details. Exit code 3 when `.athena/` is not in the index; 2 when the index has unresolved conflicts. `athena git-hook install` writes the new command (re-run it to update an existing hook; `athena git-hook status` shows `staged: false` and a hint for old hooks), and the suggested husky/lefthook line is now `npx --no-install athena sync --check --staged`.
+- The manifest detector is split into one module per ecosystem (`src/core/analyzer/detectors/manifests/`); `model.json` output is byte-identical.
+- Files modified within 2 seconds of the file index being written are re-read on the next run instead of trusted by size and mtime (Git's "racily clean" rule), so a same-size edit in the same clock tick is never missed.
+- The local server is split into route modules (`src/server/routes/*`) sharing one server context; routes, authentication, Host/Origin checks, security headers, CSP and rate limiting are unchanged.
+- `GET /api/sync` returns the proposal without `documents[].diff` (reasons, changed and preserved sections, additions/deletions and `diffTruncated` are still included). New `GET /api/sync/:doc[?planId=…]` returns one proposed document's diff; the id must be a knowledge document in the current proposal (404 otherwise, 409 when `planId` is stale). `POST /api/sync/check` still returns the full plan.
+- A corrupted `model.json` now gives a clear error with a hint (`model.json is corrupted (…)`, run `athena analyze`) instead of an internal error when starting a security scan from the web UI.
+- Test, source, auth, API and schema path patterns now come from one module (`src/core/patterns.ts`). `athena review` recognizes more test layouts (`integration_tests/`, `androidTest/`, `test_driver/`, `*_test.dart`), and change impact recognizes the same test files as review plus test runner configs.
+- New per-file facts cache in `.athena/cache/v1/` (gitignored; `cache/` is added to `.athena/.gitignore`, also for existing projects). Facts are keyed by content hash and discarded automatically when detector versions or the `ignore`/`include`/`maxFileBytes` settings change. Safe to delete; `athena clean` removes it with `.athena/`.
+- `state.json` schema 2: the file index moved to `.athena/cache/v1/files.json` (full SHA-256 hashes), so `state.json` stays small regardless of repository size. Version-1 files are migrated automatically on first read; older Athena versions will treat a v2 `state.json` as corrupted and rebuild it.
+- `athena init` creates the machine-local fingerprint salt (`.athena/local.json`) together with `.athena/`, so secret-finding fingerprints in the first `model.json` already use the project's stable key.
+
 ## 0.2.1 — 2026-09-30
 
 Security release. Upgrading is recommended for everyone. After upgrading, run `athena sync` once (the `security.md` format changed) and, if you use the pre-commit hook with `--review`, run `athena git-hook install --review` again so it reviews staged changes.

package/README.md

@@ -104,6 +104,7 @@ Apply updates to 2 documents? [y/N]
 - **Your edits are still safe.** Developer-edited sections are preserved and listed. Applying is refused if a document changed after the proposal was made.
 - When files change but no knowledge is affected, only the local index is refreshed.
 - `athena sync --check` exits with 1 when knowledge is out of date, which is useful in CI or a pre-commit hook (see [Use in CI and git hooks](#use-in-ci-and-git-hooks)). Change hotspots come from Git history and move with every commit, so the check ignores them; `athena sync` still refreshes them.
+- `athena sync --check --staged` checks what a commit would contain instead of the working tree: the `.athena/` knowledge as staged against the code as staged. Untracked files and unstaged edits don't count. This is what the pre-commit hook runs.
 - Ignore rules: defaults, root and nested `.gitignore` files, `.git/info/exclude`, and `.athena/config.json`.
 
 ## Watching what agents do
@@ -192,16 +193,22 @@ A complete workflow is in [examples/github-workflow.yml](examples/github-workflo
 ```text
 $ athena git-hook install
 ✓ Installed the pre-commit hook (knowledge check) at .git/hooks/pre-commit
-Commits are blocked when .athena/ knowledge is out of date. Teammates without Athena installed are not blocked.
-Using husky, lefthook or pre-commit? Add `npx --no-install athena sync --check` to its pre-commit config instead.
+Commits are blocked when the staged .athena/ knowledge is out of date for the staged code (untracked and unstaged files are ignored). Teammates without Athena installed are not blocked.
+Using husky, lefthook or pre-commit? Add `npx --no-install athena sync --check --staged` to its pre-commit config instead.
 
 $ git commit -m "Add refunds"
-Proposed: api.md, security.md
-Knowledge is out of date. Run `athena sync` to review and apply.
-athena: commit blocked: .athena/ knowledge is out of date. Run `athena sync`, stage .athena/ and commit again (or skip once with `git commit --no-verify`).
+  ~ api.md       endpoints
+  ~ security.md  attack-surface
+Staged knowledge is out of date for the staged code. Run `athena sync`, then stage .athena/.
+athena: commit blocked: staged .athena/ knowledge is out of date. Run `athena sync`, stage .athena/ and commit again (or skip once with `git commit --no-verify`).
 ```
 
-- `athena git-hook install --review` also runs `athena review` and blocks commits that add possible secrets or env files. It checks the whole working tree (staged, unstaged and untracked files that aren't ignored), not only what is staged.
+- The hook checks the commit, not the working tree: an untracked scratch file, a local `.env` or an unstaged edit never blocks a commit, and a change you staged and then reverted in the working tree still counts. If `athena sync` already updated a document but it isn't staged, the output says which files to `git add`.
+- The check mirrors the index into `.athena/cache/staged/` (gitignored). Files that match the working tree are stand-ins that reuse the last analysis and the facts cache, so only staged changes are read; the directory is updated incrementally and is safe to delete. Submodules are checked as they are in the working tree. Local env files that aren't committed (such as `.env`) are machine-local: the check accepts staged knowledge written with or without them.
+- Knowledge generated by `athena sync` describes the working tree. If untracked files that are not gitignored change it (a new route in a file you don't commit), the staged check reports the difference; commit, ignore or stash those files before syncing.
+- Hooks installed by earlier versions check the working tree; `athena git-hook status` points them out and `athena git-hook install` updates them.
+
+- `athena git-hook install --review` also runs `athena review --staged` and blocks commits that add possible secrets or env files. Like the knowledge check, it only looks at what is staged.
 - The hook is a `#!/bin/sh` script in the directory Git actually uses (`git rev-parse --git-path hooks`), so `core.hooksPath` and linked worktrees work. For a project in a subfolder of the repository, the hook runs Athena there.
 - If `athena` is not on `PATH`, the hook prints a note and lets the commit through, so it never blocks teammates who don't use Athena.
 - **An existing pre-commit hook is kept.** If it is a shell script, Athena adds its block between `# athena:start` and `# athena:end` right after the shebang, so it runs before your own commands. Athena refuses to touch hooks written in other languages and hooks it recognizes as managed by husky, lefthook or pre-commit (from `core.hooksPath` or the hook's contents), and prints the line to add instead.
@@ -211,7 +218,7 @@ athena: commit blocked: .athena/ knowledge is out of date. Run `athena sync`, st
 
 ```bash
 # .husky/pre-commit
-npx --no-install athena sync --check
+npx --no-install athena sync --check --staged
 ```
 
 ```yaml
@@ -219,7 +226,7 @@ npx --no-install athena sync --check
 pre-commit:
   commands:
     athena:
-      run: npx --no-install athena sync --check
+      run: npx --no-install athena sync --check --staged
 ```
 
 ### Example project

package/dist/activity-P4UUFHWV.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import {
+  listAgents
+} from "./chunk-JY6BFIJJ.js";
+import {
+  readRecentEvents,
+  summarizeSessions
+} from "./chunk-65TSRDQ3.js";
+import {
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  relativeTime,
+  sym
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-2RS6TA3D.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/activity.ts
+var STATE_COLOR = {
+  ANALYZING: c.cyan,
+  PLANNING: c.magenta,
+  CODING: c.blue,
+  TESTING: c.yellow,
+  REVIEWING: c.cyan,
+  SUCCESS: c.green,
+  IDLE: c.dim
+};
+async function activityCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const limit = Math.min(Math.max(Number(opts.limit ?? 30) || 30, 1), 500);
+  const all = await readRecentEvents(root, 500);
+  const events = (opts.agent ? all.filter((e) => e.agent === opts.agent) : all).slice(-limit);
+  if (isJson()) {
+    json({ events, sessions: summarizeSessions(all) });
+    return;
+  }
+  heading("AI Agent Activity");
+  line();
+  if (!events.length) {
+    const agents = await listAgents(root);
+    const reporting = agents.filter((a) => a.activityObservation === "hooks");
+    line(dim("No agent activity recorded yet."));
+    line(dim(reporting.length ? `Hooks are installed for: ${reporting.map((a) => a.name).join(", ")}. Events appear once an agent runs in this project.` : "Install hooks with `athena agents add claude-code` (or cursor, codex, copilot, gemini-cli) to record agent activity."));
+    return;
+  }
+  for (const e of events) {
+    const time = new Date(e.ts).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false });
+    const color = STATE_COLOR[e.state] ?? ((s) => s);
+    line(`${dim(time)}  ${color(sym.dot)} ${c.bold(e.agent)} ${dim("\xB7")} ${e.message}`);
+  }
+  line();
+  for (const s of summarizeSessions(all).slice(0, 5)) {
+    line(dim(`${s.agent} ${s.session ? `(${s.session.slice(0, 8)})` : ""}: ${s.events} events, last ${relativeTime(s.lastEventAt)}`));
+  }
+  line(dim("Only hook-reported tool use is shown. Athena cannot see agent reasoning."));
+}
+export {
+  activityCommand
+};
+//# sourceMappingURL=activity-P4UUFHWV.js.map

package/dist/agents-3HTSQGL2.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import {
+  configureAgents,
+  listAgents,
+  removeAgents
+} from "./chunk-JY6BFIJJ.js";
+import "./chunk-65TSRDQ3.js";
+import {
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  ok,
+  sym
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-2RS6TA3D.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/agents.ts
+async function agentsListCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const rows = await listAgents(root);
+  if (isJson()) {
+    json(rows);
+    return;
+  }
+  heading("AI Agent Integrations");
+  line();
+  for (const r of rows) {
+    const icon = r.configured ? c.green(sym.dot) : c.dim(sym.ring);
+    line(`${icon} ${c.bold(r.name)} ${dim(`(${r.id})`)} \u2014 ${r.configured ? "configured" : "not configured"}${r.detectedInProject ? dim(` \xB7 detected: ${r.evidence.join(", ")}`) : ""}`);
+    line(`  ${dim(r.note)}`);
+  }
+  line();
+  line(dim('"Configured" means Athena instruction files are in place. Agents with hooks also report their tool use \u2014 see `athena activity`.'));
+}
+async function agentsAddCommand(names, opts) {
+  const root = await requireProjectRoot(opts);
+  const results = await configureAgents(root, names);
+  if (isJson()) json({ ok: true, agents: results });
+  else for (const r of results) ok(`${r.id}: ${r.files.map((f) => `${f.path} (${f.action})`).join(", ")}`);
+}
+async function agentsRemoveCommand(names, opts) {
+  const root = await requireProjectRoot(opts);
+  const removed = await removeAgents(root, names);
+  if (isJson()) json({ ok: true, removed });
+  else ok(removed.length ? `Removed Athena integration from ${removed.join(", ")}` : "Nothing to remove");
+}
+export {
+  agentsAddCommand,
+  agentsListCommand,
+  agentsRemoveCommand
+};
+//# sourceMappingURL=agents-3HTSQGL2.js.map

package/dist/ai-ASL4FFQ7.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import {
+  aiStatus,
+  buildEnrichPayload,
+  enrich
+} from "./chunk-RXNRMIZP.js";
+import {
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  spinner,
+  sym,
+  warn
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-PVCIGUIT.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/ai.ts
+var CONSENT_SOURCE = { env: "ATHENA_AI_CONSENT", local: ".athena/local.json", user: "user config" };
+async function aiStatusCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const status = await aiStatus(root);
+  if (isJson()) {
+    json(status);
+    return;
+  }
+  heading("AI providers");
+  line();
+  for (const w of status.warnings) warn(c.yellow(w));
+  if (status.warnings.length) line();
+  for (const p of status.providers) {
+    const icon = p.availability.ok ? c.green(sym.ok) : c.dim(sym.ring);
+    line(`${icon} ${c.bold(p.name)}${p.selected ? c.cyan("  (selected)") : ""}`);
+    line(`    ${dim(`${p.remote ? "sends data to" : "runs locally at"} ${p.availability.endpoint} \xB7 default model ${p.defaultModel}`)}`);
+    if (!p.availability.ok) line(`    ${dim(p.availability.reason ?? "")}`);
+  }
+  line();
+  line(`Consent to send project knowledge: ${status.consent ? c.green(`granted (${CONSENT_SOURCE[status.consentSource ?? "env"]})`) : c.yellow("not granted")}`);
+  line(dim("Athena never needs AI: analysis, sync, context and MCP are deterministic. AI only produces INFERRED suggestions you review."));
+  line(dim('Configure in .athena/config.json \u2192 "ai": { "provider": "ollama" } for a fully local setup.'));
+  line(dim("Endpoint (baseUrl) and consent are machine-local only: ATHENA_AI_BASE_URL / ATHENA_AI_CONSENT=1, .athena/local.json, or ~/.config/athena/config.json."));
+}
+async function aiEnrichCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const docs = opts.docs?.split(",").map((d) => d.trim()).filter(Boolean);
+  const payload = await buildEnrichPayload(root, { docs });
+  if (!isJson()) {
+    heading("AI enrichment");
+    line();
+    for (const w of payload.warnings) warn(c.yellow(w));
+    if (payload.warnings.length) line();
+    line(`Provider:  ${c.bold(payload.provider.name)} ${dim(`(${payload.model})`)}`);
+    line(`Sends to:  ${payload.remote ? c.yellow(payload.endpoint) : c.green(`${payload.endpoint} (local)`)}`);
+    line(`Content:   ${payload.documents.join(", ")} ${dim(`(${payload.chars} characters, redacted knowledge only \u2014 no source code)`)}`);
+    line();
+  }
+  if (opts.dryRun) {
+    if (isJson()) json({ ...payload, provider: payload.provider.id });
+    else line(dim("Dry run \u2014 nothing was sent."));
+    return 0;
+  }
+  const sp = spinner(`Asking ${payload.provider.name}...`);
+  let result;
+  try {
+    result = await enrich(root, { docs, consent: opts.consent, signal: opts.signal });
+    sp.succeed(`Suggestions written to .athena/${result.file}`);
+  } catch (err) {
+    sp.stop();
+    throw err;
+  }
+  if (isJson()) json(result);
+  else {
+    line();
+    line(result.markdown.split("\n").slice(0, 40).join("\n"));
+    line();
+    line(dim(`Full suggestions: .athena/${result.file} (gitignored). These are INFERRED \u2014 nothing was added to your knowledge base.`));
+  }
+  return 0;
+}
+export {
+  aiEnrichCommand,
+  aiStatusCommand
+};
+//# sourceMappingURL=ai-ASL4FFQ7.js.map

package/dist/analyze-F3YOILNL.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import {
+  parseAgentsOption,
+  printSummary,
+  runWithProgress,
+  summarize
+} from "./chunk-DOQMAZL5.js";
+import {
+  printHeader
+} from "./chunk-SHKXELUX.js";
+import {
+  isJson,
+  json
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-SJOOXO34.js";
+import "./chunk-PANVPNYF.js";
+import "./chunk-ELKFRTZT.js";
+import "./chunk-2R6PXY6Z.js";
+import "./chunk-PVCIGUIT.js";
+import "./chunk-OLPSEQS5.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-2RS6TA3D.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/analyze.ts
+async function analyzeCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const agents = parseAgentsOption(opts.agents, false);
+  printHeader();
+  const result = await runWithProgress(root, { mode: "analyze", force: opts.force, agents, signal: opts.signal });
+  if (isJson()) json(summarize(result, root, false));
+  else printSummary(result, false, "analyze");
+}
+export {
+  analyzeCommand
+};
+//# sourceMappingURL=analyze-F3YOILNL.js.map