indusagi-coding-agent 0.2.4 → 0.2.5

package/dist/types/workflow-engine/engine.d.ts

@@ -1,183 +0,0 @@
-/**
- * runWorkflow — the deterministic workflow orchestration engine.
- *
- * A workflow script is plain JavaScript (parsed by {@link parseWorkflowScript})
- * that orchestrates a fan-out of subagents. The engine evaluates the script's
- * body inside a Node `vm` sandbox seeded with a small, frozen global surface:
- *
- *   - `agent(prompt, opts?)`  — spawn one subagent, awaitable, returns its
- *                               result (string, or the validated `opts.schema`
- *                               object). Runs under a FIFO concurrency limiter.
- *   - `parallel(thunks)`      — run an array of `() => Promise` thunks and wait
- *                               for ALL of them (a barrier); results in input
- *                               order; a failed branch logs and yields `null`.
- *   - `pipeline(items, …st)`  — run each item through the stages sequentially,
- *                               while different items proceed independently
- *                               (NO cross-item barrier); a failed stage logs and
- *                               yields `null` for that item.
- *   - `phase(title)`          — open/activate a named progress group.
- *   - `log(message)`          — append a log line.
- *   - `args`                  — the caller-supplied JSON value.
- *   - `budget`                — `{ total, spent(), remaining() }` token budget.
- *   - `cwd`                   — the working directory string.
- *   - frozen `console`        — routed into `log`.
- *
- * The actual subagent spawn is NOT owned here: the engine delegates each
- * `agent()` call to an injected {@link WorkflowAgentRunner} (stage 2 supplies a
- * real one backed by a fresh framework `Agent`; tests pass an in-memory fake).
- * This is the spawn seam that keeps the engine pure and network-free.
- *
- * Behavioral port of pi-dynamic-workflows' `runWorkflow`
- * (pi-dynamic-workflows/src/workflow.ts): same concurrency cap formula, same
- * FIFO limiter, same pending-run tracking + final `Promise.allSettled`, same
- * per-branch failure-to-null semantics, same budget loop, same abort handling,
- * same structured-clone guard on the result, same default agent labels.
- */
-import { type WorkflowMeta } from "./parse";
-/**
- * Live activity metrics for one running subagent.
- *
- * Folded by the {@link WorkflowAgentRunner} from the framework `Agent`'s event
- * stream and forwarded — via {@link WorkflowAgentRunOptions.onActivity} → the
- * engine's {@link WorkflowRunOptions.onAgentActivity} — into that agent's row in
- * the live `◆ Workflow:` progress tree.
- */
-export interface WorkflowAgentActivity {
-    /** Cumulative input tokens spent so far. */
-    tokensIn: number;
-    /** Cumulative output tokens spent so far. */
-    tokensOut: number;
-    /** How many tool calls the subagent has started. */
-    toolCount: number;
-    /** The tool the subagent is running right now, if any. */
-    currentTool?: string;
-    /** The last tool the subagent finished (when nothing is running). */
-    lastTool?: string;
-}
-/** Options the engine hands a {@link WorkflowAgentRunner} for one subagent. */
-export interface WorkflowAgentRunOptions {
-    /** The resolved, human-readable label for this subagent run. */
-    label: string;
-    /** The phase this subagent belongs to, if any. */
-    phase?: string;
-    /**
-     * Optional JSON-Schema / TypeBox schema the subagent's result must satisfy.
-     * When present the runner returns the validated object; when absent it returns
-     * the subagent's final assistant text as a string. Left as `unknown` so the
-     * engine stays decoupled from any particular schema library.
-     */
-    schema?: unknown;
-    /** Extra system guidance the engine derived (phase/model/type/isolation). */
-    instructions?: string;
-    /** Requested model id, if the script passed `opts.model`. */
-    model?: string;
-    /** Requested subagent profile/type, if the script passed `opts.agentType`. */
-    agentType?: string;
-    /** Requested isolation mode, if the script passed `opts.isolation`. */
-    isolation?: "worktree";
-    /** Abort signal forwarded from the workflow run. */
-    signal?: AbortSignal;
-    /**
-     * Called whenever the subagent's live activity changes (a tool starts/ends or
-     * a turn settles with token spend). The runner folds this from the framework
-     * `Agent` event stream; the engine forwards it to
-     * {@link WorkflowRunOptions.onAgentActivity}. Optional — a test fake may omit it.
-     */
-    onActivity?: (metrics: WorkflowAgentActivity) => void;
-}
-/**
- * The minimal contract the engine needs to spawn a subagent.
- *
- * Stage 2 implements this against a fresh, isolated framework `Agent` (the
- * delegate-runner spawn pattern): resolve the model, build the authoring deck,
- * prompt to completion, then read either the structured-output capture or the
- * final assistant text. Tests implement it with an in-memory fake so the engine
- * can be exercised with no network.
- */
-export interface WorkflowAgentRunner {
-    /**
-     * Run one subagent task and resolve with its result.
-     *
-     * @param prompt the task prompt
-     * @param options the resolved run options (label, schema, signal, …)
-     * @returns the subagent's result — a string, or the validated schema object
-     */
-    run(prompt: string, options: WorkflowAgentRunOptions): Promise<unknown>;
-}
-/** Per-subagent option bag accepted by the in-sandbox `agent()` global. */
-export interface AgentOptions {
-    /** Short unique label for the run (2-5 words); defaulted when absent. */
-    label?: string;
-    /** Override the phase this agent is attributed to. */
-    phase?: string;
-    /** Result schema; when present the agent returns the validated object. */
-    schema?: unknown;
-    /** Requested model id. */
-    model?: string;
-    /** Requested isolation mode. */
-    isolation?: "worktree";
-    /** Requested subagent profile/type. */
-    agentType?: string;
-}
-/** Options for {@link runWorkflow}. */
-export interface WorkflowRunOptions {
-    /** The injected subagent runner (required to actually spawn). */
-    agentRunner: WorkflowAgentRunner;
-    /** The JSON value exposed to the script as global `args`. */
-    args?: unknown;
-    /** The working directory exposed to the script as `cwd`/`process.cwd()`. */
-    cwd?: string;
-    /** Max concurrent subagents; clamped to `[1, 16]`. */
-    concurrency?: number;
-    /** Optional token budget; `null`/absent means unbounded. */
-    tokenBudget?: number | null;
-    /** Abort signal — aborts pending and future subagent spawns. */
-    signal?: AbortSignal;
-    /** Called for each `log()` / console line. */
-    onLog?: (message: string) => void;
-    /** Called when a new phase is activated. */
-    onPhase?: (title: string) => void;
-    /** Called just before a subagent starts. */
-    onAgentStart?: (event: {
-        id: number;
-        label: string;
-        phase?: string;
-        prompt: string;
-    }) => void;
-    /** Called when a subagent ends (`result === null` means it failed). */
-    onAgentEnd?: (event: {
-        id: number;
-        label: string;
-        phase?: string;
-        result: unknown;
-    }) => void;
-    /**
-     * Called whenever a running subagent's live activity changes (tool start/end,
-     * settled turn token spend). `id` is the 1-based start-order id that matches
-     * the `id` on the corresponding {@link onAgentStart} / {@link onAgentEnd} event.
-     */
-    onAgentActivity?: (id: number, metrics: WorkflowAgentActivity) => void;
-}
-/** The structured result of a completed workflow run. */
-export interface WorkflowRunResult<T = unknown> {
-    /** The validated workflow header. */
-    meta: WorkflowMeta;
-    /** The script's returned value (structured-clone checked). */
-    result: T;
-    /** All log lines emitted during the run, in order. */
-    logs: string[];
-    /** All phases observed during the run, in order. */
-    phases: string[];
-    /** Total subagents spawned. */
-    agentCount: number;
-    /** Wall-clock duration of the run. */
-    durationMs: number;
-}
-/**
- * Parse and run a deterministic workflow script to completion.
- *
- * @param script the raw workflow JavaScript (first statement: `export const meta`)
- * @param options the injected runner plus run configuration / callbacks
- * @returns the meta, the script's returned value, and run telemetry
- */
-export declare function runWorkflow<T = unknown>(script: string, options: WorkflowRunOptions): Promise<WorkflowRunResult<T>>;

package/dist/types/workflow-engine/engine.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/workflow-engine/index.d.ts

@@ -1,21 +0,0 @@
-/**
- * workflow-engine — the pure, network-free orchestration core for the `workflow`
- * dynamic-workflow tool.
- *
- * This barrel exposes the engine subsystem only: the deterministic script
- * parser, the `structured_output` capture tool, the progress snapshot model +
- * text renderer, and the `runWorkflow` engine with its injectable
- * {@link WorkflowAgentRunner} spawn seam. The card and console wiring (the real
- * runner backed by a fresh framework `Agent`, the `tool_update` product signal,
- * and `APP_NOVEL_CARDS` registration) live in stage 2 and consume these exports.
- */
-export type { ParsedWorkflow, WorkflowMeta, WorkflowMetaPhase, } from "./parse";
-export { NONDETERMINISM_ERROR, parseWorkflowScript } from "./parse";
-export type { StructuredOutputCapture, StructuredOutputToolOptions, } from "./structured-output";
-export { createStructuredOutputTool } from "./structured-output";
-export type { WorkflowAgentSnapshot, WorkflowAgentStatus, WorkflowDisplayOptions, WorkflowSnapshot, } from "./display";
-export { createWorkflowSnapshot, preview, recomputeWorkflowSnapshot, renderWorkflowLines, renderWorkflowText, } from "./display";
-export type { AgentOptions, WorkflowAgentActivity, WorkflowAgentRunner, WorkflowAgentRunOptions, WorkflowRunOptions, WorkflowRunResult, } from "./engine";
-export { runWorkflow } from "./engine";
-export type { WorkflowAgentRunnerOptions, WorkflowSubAgent, WorkflowSpawnContext, } from "./agent-runner";
-export { createWorkflowAgentRunner } from "./agent-runner";

package/dist/types/workflow-engine/parse.d.ts

@@ -1,64 +0,0 @@
-/**
- * Workflow script parser — extract and validate the leading `meta` export,
- * enforce determinism, and hand back the runnable sandbox body.
- *
- * A workflow script is plain JavaScript whose FIRST statement must be
- * `export const meta = { ... }` (an object literal). This module:
- *
- *   1. locates that leading export with a lexer-free, dependency-free scan,
- *   2. evaluates ONLY the `{ ... }` literal in a frozen, empty Node `vm`
- *      sandbox (no globals reachable, so the literal cannot call into
- *      anything), capturing the resulting plain object as {@link WorkflowMeta},
- *   3. validates the meta shape (name/description required, optional
- *      whenToUse/phases),
- *   4. enforces the determinism guard over the WHOLE script source —
- *      `Date.now()`, `Math.random()`, and `new Date()` are rejected so a
- *      workflow always produces the same orchestration plan, and
- *   5. strips the `export const meta = …;` statement so the remaining `body`
- *      runs as an ordinary async function body inside the engine sandbox.
- *
- * This is a dependency-free port of pi's acorn-based `parseWorkflowScript`
- * (pi-dynamic-workflows/src/workflow.ts). It deliberately does NOT pull in
- * `acorn`: the only thing the engine needs to read out of the source is the
- * leading literal, which a sandboxed `Function`/`vm` evaluation of that one
- * expression handles safely, and the determinism guard is a source string-scan
- * over the call/`new` forms pi's AST walk rejected.
- */
-/** One declared phase in the upfront `meta.phases` outline. */
-export interface WorkflowMetaPhase {
-    /** Human title for the phase row. */
-    title: string;
-    /** Optional one-line elaboration of what the phase does. */
-    detail?: string;
-    /** Optional model hint the phase prefers (documentation only). */
-    model?: string;
-}
-/** The validated `export const meta = { … }` header of a workflow script. */
-export interface WorkflowMeta {
-    /** Short snake_case identifier for the workflow. */
-    name: string;
-    /** Non-empty human description of what the workflow accomplishes. */
-    description: string;
-    /** Optional guidance on when a model should reach for this workflow. */
-    whenToUse?: string;
-    /** Optional upfront outline; live progress is still driven by `phase()`. */
-    phases?: WorkflowMetaPhase[];
-}
-/** The result of {@link parseWorkflowScript}: validated meta + runnable body. */
-export interface ParsedWorkflow {
-    /** The validated workflow header. */
-    meta: WorkflowMeta;
-    /** The script with the leading `export const meta = …` statement removed. */
-    body: string;
-}
-/** Message raised when a script reaches for a non-deterministic primitive. */
-export declare const NONDETERMINISM_ERROR = "Workflow scripts must be deterministic: Date.now()/Math.random()/new Date() are unavailable";
-/**
- * Parse a workflow script into its validated {@link WorkflowMeta} and the
- * runnable `body` (the script with the meta export removed).
- *
- * @param script the raw workflow JavaScript source
- * @throws if the first statement is not `export const meta = {literal}`, if the
- *   meta fails validation, or if the source uses a non-deterministic primitive
- */
-export declare function parseWorkflowScript(script: string): ParsedWorkflow;

package/dist/types/workflow-engine/parse.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/workflow-engine/structured-output.d.ts

@@ -1,51 +0,0 @@
-/**
- * structured_output — the per-subagent "final answer channel" tool.
- *
- * A workflow subagent that needs to return a machine-readable result is given a
- * tool named `structured_output` whose `parameters` ARE the caller-supplied
- * TypeBox schema. When the subagent calls it, the framework has already
- * validated the arguments against that schema, so `execute` simply records the
- * validated value into a shared {@link StructuredOutputCapture} and returns a
- * normal {@link AgentToolResult}.
- *
- * Difference from pi's version (pi-dynamic-workflows/src/structured-output.ts):
- * the indus-code-rebuild framework `AgentToolResult` has NO `terminate` flag
- * (see {@link "indusagi/agent"} `AgentToolResult`), so this tool does NOT end
- * the subagent's loop early. The stage-2 runner instead runs the subagent to
- * completion and reads `capture.value` afterward. This file is therefore a
- * plain {@link AgentTool} object literal (no `defineTool`, no `terminate`).
- */
-import type { Static, TSchema } from "@sinclair/typebox";
-import type { AgentTool } from "../capability-deck";
-/**
- * Mutable sink the {@link createStructuredOutputTool} tool writes into. The
- * runner constructs one per subagent run, passes it in, and reads `value` after
- * the subagent finishes.
- */
-export interface StructuredOutputCapture<T = unknown> {
-    /** The last validated payload the subagent submitted, if any. */
-    value: T | undefined;
-    /** Whether `structured_output` was ever called during the run. */
-    called: boolean;
-}
-/** Options for {@link createStructuredOutputTool}. */
-export interface StructuredOutputToolOptions<TSchemaDef extends TSchema> {
-    /** The TypeBox schema the subagent's result must satisfy. */
-    schema: TSchemaDef;
-    /** The capture sink the validated result is recorded into. */
-    capture: StructuredOutputCapture<Static<TSchemaDef>>;
-    /** Override the tool name (defaults to `structured_output`). */
-    name?: string;
-}
-/**
- * Build the `structured_output` capture tool for one subagent run.
- *
- * The returned tool's `parameters` are exactly `schema`, so the framework
- * validates the subagent's arguments before `execute` runs; `execute` then
- * records them into `capture` and acknowledges. Idempotent in the sense that a
- * second call simply overwrites `capture.value` with the newer payload.
- *
- * @param options the result schema, the capture sink, and an optional name
- * @returns an {@link AgentTool} whose parameters mirror the caller schema
- */
-export declare function createStructuredOutputTool<TSchemaDef extends TSchema>({ schema, capture, name, }: StructuredOutputToolOptions<TSchemaDef>): AgentTool<TSchemaDef, Static<TSchemaDef>>;

package/dist/types/workflow-engine/structured-output.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/workspace/brand.d.ts

@@ -1,26 +0,0 @@
-/**
- * Brand record — the single source of truth for every identity literal.
- *
- * One frozen {@link Brand} value. Nothing else in the app hard-codes the
- * product name, the profile-directory leaf, the bin names, the env-var
- * namespace, or the share-viewer origin. A rebrand edits this record and
- * nothing else.
- *
- * Shape is dictated by the boot contract ({@link Brand}); the *values* are the
- * indusagi identity.
- */
-import type { Brand } from "../boot/contract";
-/**
- * The concrete indusagi identity.
- *
- * Frozen at module scope so the record cannot be mutated by any consumer, and
- * typed `satisfies Brand` so a drift from the contract is a compile error here
- * rather than a runtime surprise downstream.
- */
-export declare const BRAND: Brand;
-/**
- * The product version — printed by `--version` and shown on the startup banner.
- * Single source of truth: bump this one line per release. Co-located with the
- * brand so `boot` reads it without importing the index barrel.
- */
-export declare const VERSION = "0.2.4";

package/dist/types/workspace/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Workspace subsystem — public barrel.
- *
- * One import site for the keyed Workspace Locator, the concrete {@link BRAND}
- * record, and the runtime/packaging detection. Boot stages depend on this
- * module rather than reaching into the individual files.
- */
-export { BRAND, VERSION } from "./brand";
-export { createWorkspace, ensureDirs, type WorkspaceOverrides, } from "./locator";
-export { isPackagedBinary, resolvePackageRoot, detectPackagingFromModuleUrl, type Packaging, } from "./runtime-detect";
-export type { Brand, Workspace } from "../boot/contract";

package/dist/types/workspace/locator.d.ts

@@ -1,50 +0,0 @@
-/**
- * Workspace Locator — turns the active {@link Brand} plus the environment into a
- * single, fully-resolved {@link Workspace} record of absolute paths.
- *
- * Replaces a family of free `get<Thing>Path()` getters with one keyed map: every
- * member of {@link Workspace} is described once as a relative location inside the
- * profile directory, and the record is built by folding that map against a
- * resolved profile root. There is no per-path function and no string literal
- * duplicated across the codebase — the layout is data.
- *
- * Resolution is pure: it reads `os.homedir()` and the process env (both
- * overridable for tests), joins against {@link Brand.profileDirName} /
- * {@link Brand.stateDirName}, and never touches the filesystem. The optional
- * {@link ensureDirs} helper is the only function that writes, and it only ever
- * `mkdir`s directories that belong to the resolved workspace.
- */
-import type { Brand, Workspace } from "../boot/contract";
-/**
- * Inputs that normally come from the OS but may be pinned for testing or
- * embedding. All optional; each defaults to its live process value.
- */
-export interface WorkspaceOverrides {
-    /** User home directory; defaults to {@link homedir}. */
-    readonly home?: string;
-    /** Working directory the resolution is anchored to; defaults to `process.cwd()`. */
-    readonly cwd?: string;
-    /** Environment to read the profile-dir override from; defaults to {@link process.env}. */
-    readonly env?: NodeJS.ProcessEnv;
-    /** Brand whose directory names drive the layout; defaults to {@link BRAND}. */
-    readonly brand?: Brand;
-}
-/**
- * Build the fully-resolved {@link Workspace} for the active brand and
- * environment.
- *
- * Pure path computation: resolves the profile root, then folds the
- * {@link LAYOUT} map into a frozen record by joining each member's segments onto
- * that root. No filesystem access — call {@link ensureDirs} separately if the
- * directories need to exist.
- */
-export declare function createWorkspace(overrides?: WorkspaceOverrides): Workspace;
-/**
- * Create every directory the workspace expects, idempotently.
- *
- * Walks the {@link DIRECTORY_KEYS} subset of the resolved {@link Workspace} and
- * `mkdir -p`s each one. Files are never created here — only their containing
- * directories — so callers can write `settings.json` et al. afterwards without
- * a missing-parent error. Returns the same workspace for chaining.
- */
-export declare function ensureDirs(workspace: Workspace): Workspace;

package/dist/types/workspace/runtime-detect.d.ts

@@ -1,56 +0,0 @@
-/**
- * Runtime / package-root detection.
- *
- * Two facts the rest of boot needs to know about *how* the process was started:
- *
- *   1. Is this a single-file compiled binary (a Bun standalone executable) or
- *      an ordinary interpreted launch (Node, or `bun run` over source)?
- *   2. Where on disk is the package root — the directory that anchors bundled
- *      assets (themes, export templates) and the `package.json` manifest?
- *
- * The compiled-binary case is *dictated by the Bun toolchain*: a standalone
- * executable resolves its own module URLs through a synthetic virtual
- * filesystem whose path component Bun spells `$bunfs` (and, depending on the
- * platform/escaping, the home-marker variants `~BUN` / `%7EBUN`). Those exact
- * markers are not a stylistic choice — they are the only signal Bun emits — so
- * we keep the literals but quarantine them inside a *single* renamed probe
- * ({@link detectPackagingFromModuleUrl}) instead of scattering the check.
- *
- * Root resolution is expressed as an ordered {@link resolveRoot} strategy table:
- * the first strategy that matches the detected packaging produces the root, so
- * adding a future strategy (e.g. an explicit override) is a row, not a branch.
- */
-/**
- * The two shapes a launch can take, from the boot layer's point of view.
- *
- *   - `compiled-binary` — a Bun standalone executable; assets live next to
- *     {@link process.execPath}, and module URLs point at Bun's virtual FS.
- *   - `interpreted` — Node, or `bun run` over a real source/`dist` tree; assets
- *     live in the directory tree containing this module.
- */
-export type Packaging = "compiled-binary" | "interpreted";
-/**
- * The lone probe over an `import.meta.url`-shaped string.
- *
- * Renamed wrapper around the (Bun-dictated) virtual-FS markers: if the module
- * URL carries any marker the launch is a compiled binary, otherwise it is an
- * interpreted run. Pure and string-only so it is trivially unit-testable
- * without spawning a real binary.
- *
- * @param moduleUrl the `import.meta.url` of the calling module.
- */
-export declare function detectPackagingFromModuleUrl(moduleUrl: string): Packaging;
-/**
- * Whether the current process is a Bun-compiled standalone binary.
- *
- * Convenience over {@link detectPackagingFromModuleUrl} bound to this module's
- * own URL — the single public predicate the rest of boot calls.
- */
-export declare function isPackagedBinary(): boolean;
-/**
- * Resolve the absolute package-root directory for the active launch.
- *
- * Detects packaging once, then folds the {@link ROOT_STRATEGIES} table to the
- * first claimant. The final row claims unconditionally, so this always returns.
- */
-export declare function resolvePackageRoot(): string;