@jinn-network/jinn-layer 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,148 @@
+/**
+ * jinn-layer CLI — the human surface over the harness-layer consume path.
+ *
+ * Verbs (same command-module spirit as client/src/cli/commands/, kept
+ * self-contained so the package stays embeddable):
+ *
+ *   jinn-layer corpus search "<query>" [--limit N] [--json]
+ *   jinn-layer corpus get <ref> [--json] [--out <dir>]
+ *   jinn-layer capture preview <task-file> [--json]
+ *
+ * Output is human-readable by default (this is a discovery surface);
+ * --json emits the typed result as JSON (artifact content base64-encoded).
+ * `capture preview` renders the scrub report: the redaction diff (original
+ * values shown on the terminal only — they never leave the machine) and the
+ * envelope exactly as it would publish. Its --json output strips the
+ * original values so it stays persistence-safe.
+ */
+import { type HarnessLayer } from './consume.js';
+import { type JinnPluginDeps } from '@jinn-network/plugin';
+import { type HarnessPublishDeps } from './publish.js';
+import { type SeedSource } from './seed-import/fetch.js';
+import { type EpisodeSource } from './seed-import/episode-fetch.js';
+import { type SeedImportStateStore } from './seed-import/state.js';
+import { type VerdictSource } from './bridge-verdict-source.js';
+import { type EvidenceFetcherPorts, type ExecutionEnvelopeAuthenticator, type PublisherSafeResolver, type VerifierFactsResolver } from './bridge-fetch-evidence.js';
+import { type DistillMode } from './distill-mode.js';
+import type { AttemptRef, BridgeEvidence } from './bridge.js';
+import type { DistillCluster, DistillLLMOutput, MetaDistillLLMOutput } from './distill.js';
+import { type ProgressStream } from './distill-progress.js';
+import type { MetaCluster } from './cluster.js';
+export type DistillProvider = 'claude' | 'codex';
+export interface DistillPorts {
+    distill: (cluster: DistillCluster) => Promise<DistillLLMOutput>;
+    metaDistill: (cluster: MetaCluster) => Promise<MetaDistillLLMOutput>;
+}
+/** Injectable deps for `distill run` (tests). Production defaults build the live wiring. */
+export interface DistillRunCliDeps {
+    /** Ledger verdict-row source (both polarities). Default: live indexer. */
+    verdictSource?: VerdictSource;
+    /** Fetch the patch + problem statement for an attempt. Default: live gateway + indexer. */
+    fetchEvidence?: (ref: AttemptRef) => Promise<BridgeEvidence>;
+    /**
+     * Production composition hook for authenticated SWE verifier facts. Receives
+     * the CLI's bounded IPFS reader so solver-specific proof resolution cannot
+     * introduce an unbounded duplicate gateway path.
+     */
+    verifierFactsResolverFactory?: (ipfs: EvidenceFetcherPorts['ipfs']) => VerifierFactsResolver;
+    /** Production composition hook for raw execution-envelope authentication. */
+    authenticateEnvelope?: ExecutionEnvelopeAuthenticator;
+    /** Production composition hook for ERC-8004 publisher → Safe resolution. */
+    resolvePublisherSafe?: PublisherSafeResolver;
+    /** The LLM distill port. Default: createClaudeDistiller. */
+    distill?: (cluster: DistillCluster) => Promise<DistillLLMOutput>;
+    /** The stage-2 meta LLM port. Default: createClaudeMetaDistiller. */
+    metaDistill?: (cluster: MetaCluster) => Promise<MetaDistillLLMOutput>;
+    /** Provider-aware port factory (tests/embedders). Default: Claude or Codex CLI ports. */
+    distillerFactory?: (provider: DistillProvider, model: string, timeoutMs?: number) => DistillPorts;
+    /** Layer-1 evidence publish deps. Default: live testnet wiring from env. */
+    publishDeps?: HarnessPublishDeps;
+    /** Held-out slate instance ids. Default: the active swe-rebench-v2 slate. */
+    slateInstanceIds?: Set<string>;
+}
+/**
+ * Injectable deps for the rung-1 `distill` own-captures loop (tests). Production
+ * defaults resolve the distill port from the provider + distiller model.
+ */
+export interface DistillCliDeps {
+    /** The LLM distill port. Default: provider factory over the resolved distiller model. */
+    distill?: (cluster: DistillCluster) => Promise<DistillLLMOutput>;
+    /** Provider-aware port factory (tests). Default: Claude or Codex CLI ports. */
+    distillerFactory?: (provider: DistillProvider, model: string, timeoutMs?: number) => DistillPorts;
+    /**
+     * Held-out slate ids — defence-in-depth over the gate + contamination scan.
+     * Own captures rarely intersect a public slate, so this defaults to empty.
+     */
+    slateInstanceIds?: Set<string>;
+    /**
+     * First-run consent resolver (#1490). Called only when the persisted mode is
+     * `unset` and the invocation is interactive. Tests inject a fake so the
+     * consent flow needs no TTY; the default is a readline prompt (see
+     * {@link readlineConsentPrompt}), used only when `isTty`.
+     */
+    promptConsent?: () => Promise<DistillMode>;
+    /**
+     * Whether to treat this invocation as interactive (tests). Default:
+     * `process.stdout.isTTY && process.stdin.isTTY`. When false and the mode is
+     * unset, the first run takes the safe default (defer) without persisting — a
+     * later interactive run still gets the prompt. It also gates the install
+     * review/prompt: non-interactive stages only (nothing installed).
+     */
+    isTty?: boolean;
+    /**
+     * Install-choice resolver (#1490). Called only when a LOCAL run produced
+     * skills, no `--install` flag was given, and the invocation is interactive.
+     * Returns the choice over the produced skill names. Tests inject a fake; the
+     * default is a readline prompt (see {@link readlineInstallPrompt}).
+     */
+    promptInstall?: (skillNames: string[]) => Promise<InstallChoice>;
+    /**
+     * Where `--progress ndjson` events are written (#1533). Default:
+     * `process.stderr` — stdout stays reserved for the `--json` result.
+     */
+    progressStream?: ProgressStream;
+}
+/** The install-review choice: everything, just the first, or none (stage only). */
+export type InstallChoice = 'all' | 'first' | 'none';
+export interface JinnLayerWriter {
+    write(value: string): boolean;
+}
+export interface RunJinnLayerCliOptions {
+    /** Injectable layer (tests). Default: createHarnessLayer() with env overrides. */
+    layer?: HarnessLayer;
+    /** Injectable publish deps (tests). Default: live testnet wiring from env. */
+    publishDeps?: HarnessPublishDeps;
+    /** Injectable seed source (tests). Default: GitHub source over --source list. */
+    seedSource?: SeedSource;
+    /** Injectable evidence-episode seed source (tests). Default: local dir source over --episodes-dir. */
+    episodeSource?: EpisodeSource;
+    /** Injectable seed-import idempotency state (tests). Default: file-backed store (real `seed execute` runs). */
+    seedImportState?: SeedImportStateStore;
+    /** Injectable distill-pipeline deps (tests). Default: live wiring per field. */
+    distillRunDeps?: DistillRunCliDeps;
+    /** Injectable rung-1 own-captures deps (tests). Default: provider-resolved distill port. */
+    distillDeps?: DistillCliDeps;
+    /** Injectable stdin reader for versioned process commands. */
+    reader?: () => Promise<string>;
+    /** Real ports are used by default; tests can override any subset. */
+    pluginOverrides?: Partial<JinnPluginDeps>;
+    writer?: JinnLayerWriter;
+}
+export interface BoundedIpfsJsonFetcherOptions {
+    gateway: string;
+    /** Default ceiling for ordinary evidence hops. Defaults to 64 MiB. */
+    defaultMaxBytes?: number;
+    /** One deadline covers response headers and streaming body reads. */
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Build the live IPFS JSON port with a caller-selectable finite byte ceiling.
+ *
+ * The stream is cancelled on the first over-limit chunk, so hostile evidence
+ * is never fully buffered before the cap is enforced. The verifier resolver
+ * uses the second argument for its tighter authenticated-artifact ceiling.
+ */
+export declare function createBoundedIpfsJsonFetcher(options: BoundedIpfsJsonFetcherOptions): EvidenceFetcherPorts['ipfs'];
+/** Returns the process exit code (0 = success). */
+export declare function runJinnLayerCli(argv: string[], opts?: RunJinnLayerCliOptions): Promise<number>;