@agent-surface/cli 0.14.0 → 0.16.0

package/dist/chunk-YUT4FVQQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/analysis.ts","../src/render/present.tsx"],"sourcesContent":["/**\n * The two halves of the surface, and the join between them.\n *\n * A presentation surface has two sources of truth, and every command needs\n * some mix of both:\n *\n * - the **catalog** — what this codebase authors. Static: `type` is a string\n *   literal, capability names are object keys, so `view:devices.table.sort` is\n *   fully determined by source text ([`extract.ts`](./extract.ts)).\n * - the **projection** — what a mounted scenario actually surfaces, after\n *   availability, policy and binding have had their say ([`collect.ts`](./collect.ts)).\n *\n * Splitting those across separate commands is what let a green `check` sit on\n * top of a route no scenario visits. So the split lives here, behind a `depth`\n * dial, and the commands compose the same three steps in whatever order their\n * output needs: `inspect` streams and closes with the verdict, `check` collects\n * and leads with it.\n */\nimport { dirname } from \"node:path\";\nimport { matchesScope } from \"@agent-surface/core/explain\";\nimport { baselineDirFor } from \"./baseline.js\";\nimport { UsageError, type Depth } from \"./contract.js\";\nimport type { CollectResult } from \"./collect.js\";\nimport {\n  allowlistPathFor,\n  buildCoverageReport,\n  readAllowlist,\n  unreadAllowlistPathFor,\n  type CoverageReport,\n} from \"./coverage.js\";\nimport {\n  authoredIds,\n  extractCapabilities,\n  readLiteralConfigScope,\n  unresolved,\n  type CapabilityInventory,\n} from \"./extract.js\";\nimport { createSurfaceRunner } from \"./load.js\";\n\nexport type { Depth } from \"./contract.js\";\nexport { UsageError } from \"./contract.js\";\n\nexport interface AnalysisOptions {\n  configPath: string;\n  depth: Depth;\n  scenario?: string;\n  scope?: string[];\n  tsconfig?: string;\n  baselineDir?: string;\n}\n\n/**\n * The static half. `undefined` at `--depth runtime`, which is the caller\n * saying it does not want this computed rather than it having failed.\n */\nexport function readInventory(options: AnalysisOptions): CapabilityInventory | undefined {\n  if (options.depth === \"runtime\") return undefined;\n  return extractCapabilities({\n    root: dirname(options.configPath),\n    ...(options.tsconfig ? { tsconfig: options.tsconfig } : {}),\n  });\n}\n\nexport function staticConfigScope(options: AnalysisOptions): string[] | undefined {\n  return options.scope ?? readLiteralConfigScope(options.configPath);\n}\n\n/** A scenario the config declares whose mount threw. Named, never swallowed. */\nexport interface ScenarioFailure {\n  scenario: string;\n  message: string;\n}\n\n/**\n * Everything knowable once the config has loaded and before the first mount:\n * which scenarios will run, under which scope, against which manifest.\n *\n * Split out so a command can *say* what it is about to measure. The mounts are\n * the slow half — on a real app, seconds of them — and a report that opens with\n * its qualifiers only after they finish spends that time showing nothing and\n * then asks the reader to re-read the numbers above.\n */\nexport interface RuntimePlan {\n  /** Scenarios selected for this run, in config order. */\n  scenarios: string[];\n  /** Every scenario declared by the config, even when one was selected. */\n  declaredScenarios: string[];\n  baselineDir: string;\n  /** CLI scope wins; otherwise the config scope is effective everywhere. */\n  scope?: string[];\n  /** Authoritative domain capability ids from the configured oRPC manifest. */\n  domainCapabilities: string[];\n  domainManifestConfigured: boolean;\n}\n\nexport interface RuntimeAnalysis extends RuntimePlan {\n  /** The ones that mounted. */\n  results: CollectResult[];\n  failures: ScenarioFailure[];\n}\n\nexport interface MountHooks {\n  /** Called once, after the config loads and before the first mount. */\n  onPlan?: (plan: RuntimePlan) => void | Promise<void>;\n  /** Called as each scenario finishes, so a command can print as it goes. */\n  onEach?: (result: CollectResult) => void | Promise<void>;\n}\n\n/**\n * The runtime half. `undefined` at `--depth static`.\n *\n * `onEach` is awaited as each scenario finishes, so a command can print as it\n * goes instead of after the last mount — a config with ten scenarios is a long\n * time to look at nothing.\n *\n * A scenario that throws is recorded and the run continues. Before this was\n * one command, `capabilities` was the only thing that still worked on an app\n * that would not mount; merging the commands would have thrown that away if a\n * single bad scenario could abort the run.\n */\nexport async function mountScenarios(\n  options: AnalysisOptions,\n  hooks: MountHooks = {},\n): Promise<RuntimeAnalysis | undefined> {\n  if (options.depth === \"static\") return undefined;\n\n  const runner = await createSurfaceRunner(options.configPath);\n  try {\n    if (options.scenario && !runner.scenarioNames.includes(options.scenario)) {\n      throw new UsageError(\n        `unknown scenario \"${options.scenario}\" — this config defines ` +\n          runner.scenarioNames.map((name) => `\"${name}\"`).join(\", \"),\n      );\n    }\n    const scenarios = options.scenario ? [options.scenario] : runner.scenarioNames;\n    const effectiveScope = options.scope ?? runner.config.scope;\n    const results: CollectResult[] = [];\n    const failures: ScenarioFailure[] = [];\n    const plan: RuntimePlan = {\n      scenarios,\n      declaredScenarios: runner.scenarioNames,\n      baselineDir: baselineDirFor(\n        options.configPath,\n        options.baselineDir ?? runner.config.baselineDir,\n      ),\n      ...(effectiveScope ? { scope: effectiveScope } : {}),\n      domainCapabilities: Object.keys(runner.config.manifest?.tools ?? {})\n        .map((path) => `domain:${path}`)\n        .sort(),\n      domainManifestConfigured: runner.config.manifest !== undefined,\n    };\n    await hooks.onPlan?.(plan);\n\n    for (const scenario of scenarios) {\n      let result: CollectResult;\n      try {\n        result = await runner.collect({\n          scenario,\n          ...(options.scope ? { scope: options.scope } : {}),\n        });\n      } catch (error) {\n        failures.push({\n          scenario,\n          message: error instanceof Error ? error.message : String(error),\n        });\n        continue;\n      }\n      results.push(result);\n      await hooks.onEach?.(result);\n    }\n\n    return { ...plan, results, failures };\n  } finally {\n    await runner.close();\n  }\n}\n\n/**\n * The component type a capability id belongs to: `view:devices.table.sort` →\n * `devices.table`. Capability names are object keys and cannot contain a dot,\n * so the last one is always the boundary; component types can and do.\n */\nfunction componentTypeOf(capabilityId: string): string {\n  const withoutPlane = capabilityId.replace(/^(view|domain):/, \"\");\n  const dot = withoutPlane.lastIndexOf(\".\");\n  return dot === -1 ? withoutPlane : withoutPlane.slice(0, dot);\n}\n\nexport function scopeInventory(\n  inventory: CapabilityInventory | undefined,\n  scope: string[] | undefined,\n): CapabilityInventory | undefined {\n  if (!inventory || !scope) return inventory;\n  return {\n    ...inventory,\n    capabilities: inventory.capabilities.filter(\n      (capability) =>\n        capability.resolution === \"unresolved\" ||\n        matchesScope(componentTypeOf(capability.capabilityId), scope),\n    ),\n  };\n}\n\nexport function scopeCapabilityIds(ids: string[], scope: string[] | undefined): string[] {\n  return scope ? ids.filter((id) => matchesScope(componentTypeOf(id), scope)) : ids;\n}\n\n/**\n * Authored minus reached (`AS-COVER-004…005`).\n *\n * Two ways this returns `undefined`, and neither is \"no gaps\":\n *\n * - a half was not computed, because the depth did not ask for it;\n * - **a scenario failed to mount.** That scenario reached nothing, so every\n *   capability it would have surfaced would be reported as one no scenario\n *   reaches. A coverage verdict computed over a partial run is precisely the\n *   misleading check this package refuses to emit, so there is no verdict\n *   until every scenario mounted. The renderer says which of the two it was.\n */\nexport function joinCoverage(\n  inventory: CapabilityInventory | undefined,\n  runtime: RuntimeAnalysis | undefined,\n  options: AnalysisOptions,\n): CoverageReport | undefined {\n  if (!inventory || !runtime) return undefined;\n  if (runtime.failures.length > 0) return undefined;\n\n  // A scope filters the mount, so it has to filter the catalog by the same\n  // predicate — core's own, not a second copy of it. Without this, `--scope\n  // devices` reported every `app.navigation` capability as unreached, with the\n  // words \"no scenario mounts it\" over two that both scenarios mount.\n  const effectiveScope = options.scope ?? runtime.scope;\n  const inScope = (capabilityId: string): boolean =>\n    matchesScope(componentTypeOf(capabilityId), effectiveScope);\n\n  const origins = new Map<string, { file: string; line: number }>();\n  for (const capability of inventory.capabilities) {\n    if (!origins.has(capability.capabilityId)) {\n      origins.set(capability.capabilityId, capability.origin);\n    }\n  }\n\n  const authored = new Set([...authoredIds(inventory)].filter(inScope));\n  for (const capabilityId of runtime.domainCapabilities) {\n    if (inScope(capabilityId)) authored.add(capabilityId);\n    if (!origins.has(capabilityId)) {\n      origins.set(capabilityId, { file: \"oRPC manifest\", line: 0 });\n    }\n  }\n  const reachedIds = new Set<string>();\n  for (const result of runtime.results) {\n    for (const capability of result.explanation.capabilities) {\n      reachedIds.add(capability.capabilityId);\n    }\n  }\n\n  // The allowlist is a statement about the whole catalog, and a scoped run has\n  // only looked at part of it. Judging an out-of-scope entry either way would\n  // be wrong in both directions — it is not an unreached capability this run\n  // waved through, and it is not a stale entry either, because nothing here\n  // reached it.\n  const allowlistPath = allowlistPathFor(runtime.baselineDir);\n  const wholeAllowlist = readAllowlist(allowlistPath);\n  const allowlist = Object.fromEntries(\n    Object.entries(wholeAllowlist).filter(([id]) => inScope(id)),\n  );\n\n  // Not scope-filtered, deliberately: an unread call site has no capability id,\n  // so there is no component type to test a scope prefix against. A scoped run\n  // simply reports the same unread sites as an unscoped one.\n  const unreadAllowlistPath = unreadAllowlistPathFor(runtime.baselineDir);\n\n  return buildCoverageReport({\n    unreadAllowlist: readAllowlist(unreadAllowlistPath, \"file#reason#site\"),\n    unreadAllowlistPath,\n    domainAuthoritative: runtime.domainManifestConfigured,\n    authored,\n    origins,\n    reachedIds,\n    scenarios: runtime.scenarios,\n    ...(effectiveScope ? { scope: effectiveScope } : {}),\n    unresolved: unresolved(inventory),\n    allowlist,\n    allowlistOutOfScope: Object.keys(wholeAllowlist).length - Object.keys(allowlist).length,\n    allowlistPath,\n  });\n}\n","/**\n * The presenter: one report, one look, whichever command produced it.\n *\n * Every human-facing command builds [`ReportPart`s](./summary.ts) and hands them\n * here. Nothing else in this package decides between the terminal UI and plain\n * text, waits on a spinner, or writes a blank line — which is the point. That\n * choice used to be made at each call site, so `check` and `snapshot` never drew\n * a terminal UI at all, `inspect` printed its static catalog and its mount\n * failures as raw text in the middle of a rendered report, and the same block\n * carried a different text column in each of them.\n *\n * Three invariants it exists to keep:\n *\n * - **One renderer per stream, decided once.** Ink when that stream is a\n *   terminal, plain text otherwise (`AS-CLI-003`), for every part of the run.\n * - **One blank line between parts**, on both paths. Ink ends each painted frame\n *   with a newline and plain text has to be asked for one, so the callers stop\n *   sprinkling `\\n` and getting it wrong in one of the two.\n * - **One label grid.** The text column belongs to the report, not to the block,\n *   and it can only ever widen — so `Config`, `Capabilities` and `Coverage` line\n *   up whether they were printed a second or a minute apart.\n */\nimport { isPlain, loadInk, paint, transient, write, type OutputFlags } from \"../output.js\";\nimport { renderPartPlain } from \"./plain.js\";\nimport { LABEL_WIDTH, reportGrid, type ReportPart, type ReportStream } from \"./summary.js\";\n\nexport interface Presenter {\n  /** Draws parts in order, one blank line between them. */\n  emit(...parts: ReportPart[]): Promise<void>;\n  /** Names the slow thing currently happening. A no-op in plain mode. */\n  wait(label: string): Promise<void>;\n  /** Clears any spinner. Called for you before anything is drawn. */\n  settle(): void;\n}\n\ntype InkModule = NonNullable<Awaited<ReturnType<typeof loadInk>>>;\n\nclass ReportPresenter implements Presenter {\n  /** `null` on a stream rendering plain text — piped, CI, `--plain`, React 18. */\n  readonly #out: InkModule | null;\n  readonly #err: InkModule | null;\n  /** Sticky, and only ever wider: a grid that shrank mid-report is two grids. */\n  #labelWidth = LABEL_WIDTH;\n  #wrote = false;\n  /**\n   * Whether the last part was written as plain text. Ink's own frame supplies\n   * the blank line after it; plain text has to be asked for one before the next\n   * part. Tracking which drew last is what keeps the spacing identical when a\n   * drawn report sends a finding to a redirected stderr.\n   */\n  #plainLast = false;\n  #stop: (() => void) | undefined;\n\n  constructor(out: InkModule | null, err: InkModule | null) {\n    this.#out = out;\n    this.#err = err;\n  }\n\n  async emit(...parts: ReportPart[]): Promise<void> {\n    for (const part of parts) await this.#draw(part);\n  }\n\n  async wait(label: string): Promise<void> {\n    this.settle();\n    // Nothing transient is ever written in plain mode: `AS-CLI-003` wants\n    // byte-stable output, and a spinner is neither.\n    const ink = this.#out;\n    if (ink) this.#stop = await transient(<ink.Loading label={label} />);\n  }\n\n  settle(): void {\n    this.#stop?.();\n    this.#stop = undefined;\n  }\n\n  async #draw(part: ReportPart): Promise<void> {\n    // A spinner is a live frame: anything written under it lands in the region\n    // Ink is about to erase.\n    this.settle();\n    const stream: ReportStream = part.stream ?? \"out\";\n    if (part.kind === \"blocks\") {\n      this.#labelWidth = Math.max(this.#labelWidth, reportGrid(part.blocks, LABEL_WIDTH).label);\n    }\n    const separate = this.#wrote && this.#plainLast;\n    const ink = stream === \"err\" ? this.#err : this.#out;\n\n    if (ink) {\n      if (separate) write(\"\", stream);\n      await paint(<ink.Part part={part} labelWidth={this.#labelWidth} />, stream);\n    } else {\n      const text = renderPartPlain(part, this.#labelWidth);\n      if (text.length === 0) return;\n      write(separate ? `\\n${text}` : text, stream);\n    }\n    this.#plainLast = ink === null;\n    this.#wrote = true;\n  }\n}\n\n/**\n * The presenter for this run.\n *\n * `--json` resolves to the plain path and its spinner to nothing, so a command\n * emitting data rather than a report simply has no parts to emit — it never has\n * to ask which renderer it is talking to.\n */\nexport async function createPresenter(flags: OutputFlags): Promise<Presenter> {\n  const drawn = !isPlain(flags, \"out\") || !isPlain(flags, \"err\");\n  // `null` when Ink cannot run here (React 18 host), which is a fallback to\n  // plain text rather than a failed command — see loadInk().\n  const ink = drawn ? await loadInk() : null;\n  return new ReportPresenter(\n    ink && !isPlain(flags, \"out\") ? ink : null,\n    ink && !isPlain(flags, \"err\") ? ink : null,\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/collect.js

@@ -1,52 +0,0 @@
-import {
-  mountScenario
-} from "./chunk-A2G4QLX5.js";
-
-// src/collect.ts
-import { explainSurface } from "@agent-surface/core/explain";
-async function collect(config, options) {
-  const mount = await mountScenario(config, options.scenario, {
-    ...options.consumer ? { consumer: options.consumer } : {}
-  });
-  const scope = options.scope ?? config.scope;
-  const ctx = {
-    consumer: mount.consumer,
-    includeUnavailable: true,
-    ...scope ? { scope } : {}
-  };
-  try {
-    return {
-      scenario: options.scenario,
-      // Inert copies: the live objects are frozen and graph-local, and only
-      // plain JSON may cross back into the CLI process.
-      snapshot: jsonify(mount.mounted.registry.snapshot(ctx)),
-      explanation: jsonify(explainSurface(mount.mounted.registry, ctx)),
-      // The harness subscribes to the registry when it is constructed, which is
-      // before the tree renders — so this is the whole mount, not what happened
-      // to still be pending when the render finished.
-      rejections: rejectionsFrom(mount.surface.events()),
-      ...scope ? { scope } : {}
-    };
-  } finally {
-    mount.surface.dispose();
-  }
-}
-function rejectionsFrom(events) {
-  const rejections = [];
-  for (const event of events) {
-    if (event.type !== "component-rejected") continue;
-    rejections.push({
-      componentType: event.componentType,
-      instanceId: event.instanceId,
-      reason: event.reason
-    });
-  }
-  return rejections;
-}
-function jsonify(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-export {
-  collect
-};
-//# sourceMappingURL=collect.js.map

package/dist/collect.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/collect.ts"],"sourcesContent":["/**\n * The collector — the *only* module the CLI executes inside the vite-node\n * graph, and the reason that boundary exists.\n *\n * Two things force it:\n *\n * 1. **One React.** The app's component tree resolves React through the app's\n *    own Vite config. If the mount ran in the CLI's Node graph instead, a\n *    second React copy would render it and every hook would throw.\n *\n * 2. **One `@agent-surface/core`.** `explainSurface()` reaches the registry\n *    through a plain `Symbol` seam, and a symbol is only equal to itself within\n *    one module instance. Load core twice and the seam silently misses. So the\n *    explanation is computed *here*, beside the registry that owns it.\n *\n * Everything crosses back as plain JSON. Nothing live — no registry, no React\n * element, no policy function — escapes into the CLI process.\n */\nimport { explainSurface, type SurfaceExplanation } from \"@agent-surface/core/explain\";\nimport type {\n  AgentConsumer,\n  AgentSurfaceEvent,\n  AgentSurfaceSnapshot,\n  SnapshotContext,\n} from \"@agent-surface/core\";\nimport type { SurfaceConfig } from \"./config.js\";\nimport { mountScenario } from \"./mount.js\";\n\nexport interface CollectOptions {\n  scenario: string;\n  consumer?: AgentConsumer;\n  scope?: string[];\n}\n\n/**\n * A registration the registry refused while the scenario mounted (`AS-CLI-006`).\n *\n * Rejection is the one failure that is invisible everywhere else. The handle is\n * dead, so the capability never reaches the snapshot; the registration never\n * became active, so `explainSurface()` does not iterate it either. The only\n * diagnostic core emits goes through `devError`, which prints nothing unless\n * the app was built with `environment: \"development\"` — and the config shape\n * this CLI documents builds it with `\"test\"`.\n */\nexport interface RegistrationRejection {\n  componentType: string;\n  instanceId: string;\n  reason: \"duplicate\" | \"guard\";\n}\n\nexport interface CollectResult {\n  scenario: string;\n  snapshot: AgentSurfaceSnapshot;\n  explanation: SurfaceExplanation;\n  /** Refused during this mount. Empty on a healthy one. */\n  rejections: RegistrationRejection[];\n  /** The scope the two projections above were computed under, when one was set. */\n  scope?: string[];\n}\n\nexport async function collect(\n  config: SurfaceConfig,\n  options: CollectOptions,\n): Promise<CollectResult> {\n  const mount = await mountScenario(config, options.scenario, {\n    ...(options.consumer ? { consumer: options.consumer } : {}),\n  });\n  const scope = options.scope ?? config.scope;\n  const ctx: SnapshotContext = {\n    consumer: mount.consumer,\n    includeUnavailable: true,\n    ...(scope ? { scope } : {}),\n  };\n\n  try {\n    return {\n      scenario: options.scenario,\n      // Inert copies: the live objects are frozen and graph-local, and only\n      // plain JSON may cross back into the CLI process.\n      snapshot: jsonify(mount.mounted.registry.snapshot(ctx)),\n      explanation: jsonify(explainSurface(mount.mounted.registry, ctx)),\n      // The harness subscribes to the registry when it is constructed, which is\n      // before the tree renders — so this is the whole mount, not what happened\n      // to still be pending when the render finished.\n      rejections: rejectionsFrom(mount.surface.events()),\n      ...(scope ? { scope } : {}),\n    };\n  } finally {\n    mount.surface.dispose();\n  }\n}\n\nfunction rejectionsFrom(events: readonly AgentSurfaceEvent[]): RegistrationRejection[] {\n  const rejections: RegistrationRejection[] = [];\n  for (const event of events) {\n    if (event.type !== \"component-rejected\") continue;\n    rejections.push({\n      componentType: event.componentType,\n      instanceId: event.instanceId,\n      reason: event.reason,\n    });\n  }\n  return rejections;\n}\n\nfunction jsonify<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value)) as T;\n}\n"],"mappings":";;;;;AAkBA,SAAS,sBAA+C;AA0CxD,eAAsB,QACpB,QACA,SACwB;AACxB,QAAM,QAAQ,MAAM,cAAc,QAAQ,QAAQ,UAAU;AAAA,IAC1D,GAAI,QAAQ,WAAW,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC;AAAA,EAC3D,CAAC;AACD,QAAM,QAAQ,QAAQ,SAAS,OAAO;AACtC,QAAM,MAAuB;AAAA,IAC3B,UAAU,MAAM;AAAA,IAChB,oBAAoB;AAAA,IACpB,GAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;AAAA,EAC3B;AAEA,MAAI;AACF,WAAO;AAAA,MACL,UAAU,QAAQ;AAAA;AAAA;AAAA,MAGlB,UAAU,QAAQ,MAAM,QAAQ,SAAS,SAAS,GAAG,CAAC;AAAA,MACtD,aAAa,QAAQ,eAAe,MAAM,QAAQ,UAAU,GAAG,CAAC;AAAA;AAAA;AAAA;AAAA,MAIhE,YAAY,eAAe,MAAM,QAAQ,OAAO,CAAC;AAAA,MACjD,GAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;AAAA,IAC3B;AAAA,EACF,UAAE;AACA,UAAM,QAAQ,QAAQ;AAAA,EACxB;AACF;AAEA,SAAS,eAAe,QAA+D;AACrF,QAAM,aAAsC,CAAC;AAC7C,aAAW,SAAS,QAAQ;AAC1B,QAAI,MAAM,SAAS,qBAAsB;AACzC,eAAW,KAAK;AAAA,MACd,eAAe,MAAM;AAAA,MACrB,YAAY,MAAM;AAAA,MAClB,QAAQ,MAAM;AAAA,IAChB,CAAC;AAAA,EACH;AACA,SAAO;AACT;AAEA,SAAS,QAAW,OAAa;AAC/B,SAAO,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;AACzC;","names":[]}

package/dist/config-rHD2wEws.d.ts

@@ -1,60 +0,0 @@
-import { ReactElement } from 'react';
-import { AgentSurfaceRegistry, AgentConsumer } from '@agent-surface/core';
-
-/** Structural subset of the authoritative orpc-agent manifest the CLI consumes. */
-interface SurfaceDomainManifest {
-    tools: Record<string, {
-        description: string;
-    }>;
-}
-/** What `mount()` hands back: the app's own registry and its rendered tree. */
-interface MountResult<TApp = unknown> {
-    registry: AgentSurfaceRegistry;
-    ui: ReactElement;
-    /**
-     * Anything else your tests need back — the app wiring, a backend double, a
-     * router handle. The CLI ignores it entirely; it exists so the same scenario
-     * can drive `agent-surface inspect` and a Vitest suite without the suite
-     * having to rebuild the app a second way.
-     */
-    app?: TApp;
-}
-/**
- * Scenario properties are whatever your `mount()` needs — a user, a route, a
- * feature flag. The CLI never interprets them; it just hands them back, plus
- * `scenario` (the key it was listed under).
- */
-type ScenarioProps = Record<string, unknown>;
-interface SurfaceConfig<TScenario extends ScenarioProps = ScenarioProps, TApp = unknown> {
-    /**
-     * Build the app the way the app builds itself. This should point at your
-     * existing composition root, not restate it — whatever `main.tsx` calls.
-     */
-    mount(props: TScenario & {
-        scenario: string;
-    }): MountResult<TApp> | Promise<MountResult<TApp>>;
-    /**
-     * Optional extra settling after mount effects flush, for anything the first
-     * render kicks off asynchronously (an initial fetch, a router resolve).
-     * The CLI already flushes React effects and pending microtasks for you.
-     */
-    settle?: (mounted: MountResult<TApp>) => void | Promise<void>;
-    /** Named surfaces to inspect and check. At least one is required. */
-    scenarios: Record<string, TScenario>;
-    /** Consumer identity snapshots are computed for. Default `{id:"cli",kind:"test"}`. */
-    consumer?: AgentConsumer;
-    /** Component-type prefixes to restrict to, same meaning as `SnapshotContext.scope`. */
-    scope?: string[];
-    /** Authoritative domain denominator. Full analysis joins every manifest tool. */
-    manifest?: SurfaceDomainManifest;
-    /** Where `snapshot`/`check` keep baselines. Default `.agent-surface`, relative to the config. */
-    baselineDir?: string;
-}
-/**
- * Identity function that exists purely for type inference — the same shape as
- * Vite's `defineConfig`. Your scenario props stay strongly typed inside
- * `mount()` without you annotating them.
- */
-declare function defineSurface<TScenario extends ScenarioProps, TApp = unknown>(config: SurfaceConfig<TScenario, TApp>): SurfaceConfig<TScenario, TApp>;
-
-export { type MountResult as M, type ScenarioProps as S, type SurfaceConfig as a, defineSurface as d };

package/dist/init-64GIHMKV.js

@@ -1,164 +0,0 @@
-import {
-  createPresenter
-} from "./chunk-YUT4FVQQ.js";
-import {
-  UsageError,
-  isPlain,
-  loadInk,
-  writeError
-} from "./chunk-G7Z6PP6C.js";
-import {
-  READING_SOURCE,
-  authoredIds,
-  catalogDetailParts,
-  catalogRows,
-  displayPath,
-  extractCapabilities,
-  findTsconfig
-} from "./chunk-LQUL4OIA.js";
-
-// src/commands/init.tsx
-import { existsSync, writeFileSync } from "fs";
-import { join } from "path";
-import { jsx } from "react/jsx-runtime";
-var CONFIG_NAME = "agent-surface.config.tsx";
-var ENTRY_CANDIDATES = [
-  "src/main.tsx",
-  "src/main.ts",
-  "src/index.tsx",
-  "src/App.tsx",
-  "src/app/App.tsx",
-  "app/root.tsx"
-];
-function scaffold(entry) {
-  const importPath = entry ? `./${entry.replace(/\.tsx?$/, ".js")}` : "./src/App.js";
-  return `import { defineSurface } from "@agent-surface/cli";
-// TODO: point these at your own composition root \u2014 whatever \`main.tsx\` calls.
-// The config should *reuse* how the app builds itself, not restate it.
-import { App } from "${importPath}";
-
-export default defineSurface({
-  mount: ({ user }) => {
-    // TODO: build the app the way the app builds itself, and hand back the
-    // registry it created plus the tree that registers into it.
-    const app = createApp({ environment: "test", user });
-    return { registry: app.registry, ui: <App app={app} />, app };
-  },
-
-  // Named prop bundles. Free-form \u2014 a user, a route, a feature flag; the CLI
-  // never interprets them. Every scenario you leave out is a surface nothing
-  // measures, which is what \`--depth full\` reports as unreached.
-  scenarios: {
-    default: { user: { id: "u_1", permissions: [] } },
-  },
-});
-`;
-}
-async function runInit(options) {
-  const configPath = join(options.cwd, CONFIG_NAME);
-  if (existsSync(configPath)) {
-    throw new UsageError(
-      `${displayPath(configPath)} already exists \u2014 edit it, or delete it and re-run`
-    );
-  }
-  const tsconfig = options.tsconfig ?? findTsconfig(options.cwd);
-  if (!tsconfig) {
-    throw new UsageError(
-      `no tsconfig.json found from ${options.cwd} \u2014 agent-surface reads your TypeScript program to find registration call sites, and cannot do that without one`
-    );
-  }
-  const present = await createPresenter(options);
-  await present.wait(READING_SOURCE);
-  const inventory = extractCapabilities({ root: options.cwd, tsconfig });
-  const ids = authoredIds(inventory);
-  const entry = ENTRY_CANDIDATES.find((candidate) => existsSync(join(options.cwd, candidate)));
-  const parts = [
-    {
-      kind: "blocks",
-      blocks: [
-        {
-          title: "SURFACE INIT",
-          rows: [
-            { label: "Tsconfig", text: displayPath(tsconfig) },
-            { label: "Config", text: `${displayPath(configPath)} \u2014 to be written` }
-          ]
-        },
-        { title: "STATIC CATALOG", rows: catalogRows(inventory) }
-      ]
-    },
-    ...ids.size > 0 ? catalogDetailParts(inventory) : []
-  ];
-  if (ids.size === 0) {
-    parts.push({
-      kind: "note",
-      lines: [
-        "Nothing is annotated yet \u2014 that is the default, and it is the safe one: a capability",
-        "exists only where someone wrote one. Start with `useAgentComponent` in a component",
-        "that owns state worth acting on, then re-run this."
-      ]
-    });
-  }
-  parts.push({
-    kind: "note",
-    title: "SCAFFOLD",
-    lines: [
-      `  ${displayPath(configPath)}`,
-      entry ? `  imports ./${entry}, which you will still have to wire into a mount()` : "  no app entry found, so the import line is a placeholder you will have to point somewhere"
-    ]
-  });
-  await present.emit(...parts);
-  if (!options.yes) {
-    const answered = await ask(options, `Write ${CONFIG_NAME}?`);
-    if (!answered) {
-      await present.emit({ kind: "note", lines: ["Nothing written."] });
-      return 0;
-    }
-  }
-  writeFileSync(configPath, scaffold(entry), "utf8");
-  await present.emit(
-    { kind: "note", lines: [`wrote ${displayPath(configPath)}`] },
-    {
-      kind: "steps",
-      title: "NEXT STEPS",
-      steps: [
-        "fill in mount() \u2014 it should call your existing composition root",
-        "`agent-surface inspect` to see what an agent can reach",
-        "`agent-surface snapshot` to commit the baseline, then `check` in CI"
-      ]
-    }
-  );
-  return 0;
-}
-async function ask(options, question) {
-  if (isPlain(options) || process.stdin.isTTY !== true) {
-    writeError("");
-    writeError("stdin is not a terminal, so there is nobody to ask \u2014 re-run with --yes to accept.");
-    return false;
-  }
-  const ink = await loadInk();
-  if (!ink) {
-    writeError("");
-    writeError("no interactive renderer available here \u2014 re-run with --yes to accept.");
-    return false;
-  }
-  const { render } = await import("ink");
-  return new Promise((resolve) => {
-    const instance = render(
-      /* @__PURE__ */ jsx(
-        ink.Confirm,
-        {
-          question,
-          onAnswer: (yes) => {
-            instance.clear();
-            instance.unmount();
-            resolve(yes);
-          }
-        }
-      )
-    );
-  });
-}
-export {
-  runInit
-};
-//# sourceMappingURL=init-64GIHMKV.js.map

package/dist/init-64GIHMKV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/commands/init.tsx"],"sourcesContent":["import { existsSync, writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { UsageError } from \"../analysis.js\";\nimport { authoredIds, extractCapabilities, findTsconfig } from \"../extract.js\";\nimport { isPlain, loadInk, writeError } from \"../output.js\";\nimport { createPresenter } from \"../render/present.js\";\nimport {\n  catalogDetailParts,\n  catalogRows,\n  displayPath,\n  READING_SOURCE,\n  type ReportPart,\n} from \"../render/summary.js\";\n\nexport interface InitOptions {\n  cwd: string;\n  tsconfig?: string;\n  yes?: boolean;\n  plain?: boolean;\n}\n\nconst CONFIG_NAME = \"agent-surface.config.tsx\";\n\n/**\n * Where an app is usually assembled. `init` does not *probe* these — it cannot,\n * because a surface config needs a `mount()` that builds the app, and there is\n * no export a tool can import to get one. It names the likeliest file so the\n * scaffold's import line points somewhere real more often than not.\n */\nconst ENTRY_CANDIDATES = [\n  \"src/main.tsx\",\n  \"src/main.ts\",\n  \"src/index.tsx\",\n  \"src/App.tsx\",\n  \"src/app/App.tsx\",\n  \"app/root.tsx\",\n];\n\nfunction scaffold(entry: string | undefined): string {\n  const importPath = entry ? `./${entry.replace(/\\.tsx?$/, \".js\")}` : \"./src/App.js\";\n  return `import { defineSurface } from \"@agent-surface/cli\";\n// TODO: point these at your own composition root — whatever \\`main.tsx\\` calls.\n// The config should *reuse* how the app builds itself, not restate it.\nimport { App } from \"${importPath}\";\n\nexport default defineSurface({\n  mount: ({ user }) => {\n    // TODO: build the app the way the app builds itself, and hand back the\n    // registry it created plus the tree that registers into it.\n    const app = createApp({ environment: \"test\", user });\n    return { registry: app.registry, ui: <App app={app} />, app };\n  },\n\n  // Named prop bundles. Free-form — a user, a route, a feature flag; the CLI\n  // never interprets them. Every scenario you leave out is a surface nothing\n  // measures, which is what \\`--depth full\\` reports as unreached.\n  scenarios: {\n    default: { user: { id: \"u_1\", permissions: [] } },\n  },\n});\n`;\n}\n\n/**\n * `agent-surface init` — the on-ramp.\n *\n * It reads the codebase first and writes nothing before it has shown you what\n * it found. That order is the whole point: the number it prints is the one\n * every later command is relative to, and a scaffold that appears before the\n * summary asks you to accept a config for a codebase neither of you has looked\n * at yet.\n *\n * It mounts nothing and needs no config to exist — it is `--depth static` with\n * a file write on the end, and it says so in the same blocks `inspect --depth\n * static` uses, so the first report a reader ever sees is the one they will go\n * on seeing.\n */\nexport async function runInit(options: InitOptions): Promise<number> {\n  const configPath = join(options.cwd, CONFIG_NAME);\n  if (existsSync(configPath)) {\n    throw new UsageError(\n      `${displayPath(configPath)} already exists — edit it, or delete it and re-run`,\n    );\n  }\n\n  const tsconfig = options.tsconfig ?? findTsconfig(options.cwd);\n  if (!tsconfig) {\n    throw new UsageError(\n      `no tsconfig.json found from ${options.cwd} — agent-surface reads your TypeScript program ` +\n        \"to find registration call sites, and cannot do that without one\",\n    );\n  }\n\n  const present = await createPresenter(options);\n  await present.wait(READING_SOURCE);\n  const inventory = extractCapabilities({ root: options.cwd, tsconfig });\n  const ids = authoredIds(inventory);\n  const entry = ENTRY_CANDIDATES.find((candidate) => existsSync(join(options.cwd, candidate)));\n\n  const parts: ReportPart[] = [\n    {\n      kind: \"blocks\",\n      blocks: [\n        {\n          title: \"SURFACE INIT\",\n          rows: [\n            { label: \"Tsconfig\", text: displayPath(tsconfig) },\n            { label: \"Config\", text: `${displayPath(configPath)} — to be written` },\n          ],\n        },\n        { title: \"STATIC CATALOG\", rows: catalogRows(inventory) },\n      ],\n    },\n    ...(ids.size > 0 ? catalogDetailParts(inventory) : []),\n  ];\n\n  if (ids.size === 0) {\n    parts.push({\n      kind: \"note\",\n      lines: [\n        \"Nothing is annotated yet — that is the default, and it is the safe one: a capability\",\n        \"exists only where someone wrote one. Start with `useAgentComponent` in a component\",\n        \"that owns state worth acting on, then re-run this.\",\n      ],\n    });\n  }\n\n  parts.push({\n    kind: \"note\",\n    title: \"SCAFFOLD\",\n    lines: [\n      `  ${displayPath(configPath)}`,\n      entry\n        ? `  imports ./${entry}, which you will still have to wire into a mount()`\n        : \"  no app entry found, so the import line is a placeholder you will have to point somewhere\",\n    ],\n  });\n  await present.emit(...parts);\n\n  if (!options.yes) {\n    const answered = await ask(options, `Write ${CONFIG_NAME}?`);\n    if (!answered) {\n      await present.emit({ kind: \"note\", lines: [\"Nothing written.\"] });\n      return 0;\n    }\n  }\n\n  writeFileSync(configPath, scaffold(entry), \"utf8\");\n  await present.emit(\n    { kind: \"note\", lines: [`wrote ${displayPath(configPath)}`] },\n    {\n      kind: \"steps\",\n      title: \"NEXT STEPS\",\n      steps: [\n        \"fill in mount() — it should call your existing composition root\",\n        \"`agent-surface inspect` to see what an agent can reach\",\n        \"`agent-surface snapshot` to commit the baseline, then `check` in CI\",\n      ],\n    },\n  );\n  return 0;\n}\n\n/**\n * There is no prompt to give when nothing is attached to answer it. Failing\n * with the flag that would have worked beats writing a file the caller never\n * agreed to, and beats hanging on a read that will never return.\n */\nasync function ask(options: InitOptions, question: string): Promise<boolean> {\n  if (isPlain(options) || process.stdin.isTTY !== true) {\n    writeError(\"\");\n    writeError(\"stdin is not a terminal, so there is nobody to ask — re-run with --yes to accept.\");\n    return false;\n  }\n  const ink = await loadInk();\n  if (!ink) {\n    writeError(\"\");\n    writeError(\"no interactive renderer available here — re-run with --yes to accept.\");\n    return false;\n  }\n  const { render } = await import(\"ink\");\n  return new Promise<boolean>((resolve) => {\n    const instance = render(\n      <ink.Confirm\n        question={question}\n        onAnswer={(yes) => {\n          instance.clear();\n          instance.unmount();\n          resolve(yes);\n        }}\n      />,\n    );\n  });\n}\n"],"mappings":"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","names":[]}