indusagi-coding-agent 0.2.2 → 0.2.3

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

@@ -0,0 +1,64 @@
+/**
+ * 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

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

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

@@ -0,0 +1,51 @@
+/**
+ * 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

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

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

@@ -23,4 +23,4 @@ export declare const BRAND: Brand;
  * 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.0";
+export declare const VERSION = "0.2.3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indusagi-coding-agent",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Indusagi coding agent — a terminal-first AI coding agent, built from scratch on the indusagi framework.",
   "author": "Varun Israni",
   "license": "MIT",
@@ -57,7 +57,7 @@
     "@sinclair/typebox": "^0.34.49",
     "chalk": "^5.6.2",
     "highlight.js": "^11.11.1",
-    "indusagi": "^0.13.1",
+    "indusagi": "^0.13.2",
     "ink": "^5.2.1",
     "jiti": "^2.7.0",
     "marked": "^18.0.4",

package/dist/types/console/components/Emblem.d.ts

@@ -1,49 +0,0 @@
-/**
- * Emblem — the two-tone block monogram that sits to the left of the wordmark
- * (roadmap #2).
- *
- * Before this, the masthead was lettering alone — the "INDUS CODE" wordmark
- * *was* the whole identity, painted in one flat accent. The emblem gives the
- * brand a *mark*: a small fixed-width block glyph built from the box quadrant
- * family (`▛ ▜ ▙ ▟ ▝ ▘ ▗ ▖ █ ▓`), split per row into a bright "fill" span and a
- * dim "shadow" span so it reads as a single solid shape lit from one corner.
- * The fill is the primary accent; the shadow is the secondary accent — the two
- * distinct palette hues the scheme already carries — so the mark is genuinely
- * two-tone rather than a single colour with a darker edge.
- *
- * It is purely presentational: a fixed glyph grid tinted through the framework
- * {@link InkThemeAdapter} at render time, no state, no effects, no props beyond
- * the theme and an optional row-colour override the banner uses to fold the
- * emblem's fill into a frozen colour-sweep.
- *
- * Layout is a `flexDirection="column"` of one `<Box>` per row; within a row the
- * fill and shadow are adjacent `<Text>` spans so each row's two tones share a
- * line. The whole emblem is the same display width on every row, so it stacks
- * into a clean column the wordmark can sit beside in a parent row Box.
- */
-import type { InkThemeAdapter } from "indusagi/react-ink";
-/** How many terminal rows the emblem occupies (its glyph-grid height). */
-export declare const EMBLEM_HEIGHT: number;
-/** What the {@link Emblem} renders. */
-export interface EmblemProps {
-    /** The framework adapter that turns token roles into terminal colours. */
-    readonly theme: InkThemeAdapter;
-    /**
-     * Optional per-row fill colour (a `#rrggbb` hex), indexed by row. When supplied
-     * (the banner's frozen colour-sweep), row `i`'s fill is painted with
-     * `rowColors[i]` via chalk's hex path instead of the flat accent role; the
-     * shadow keeps the secondary accent so the mark stays two-tone. Absent rows
-     * fall back to the accent role.
-     */
-    readonly rowColors?: readonly string[];
-}
-/**
- * Render the two-tone block emblem.
- *
- * Each row paints its fill span in the accent role (or the supplied sweep colour
- * for that row) and its shadow span in the secondary `customMessage` role, so the
- * monogram reads as one solid mark with a lit and a shadowed face.
- *
- * @param props the theme adapter and an optional per-row fill-colour override
- */
-export declare function Emblem({ theme, rowColors }: EmblemProps): JSX.Element;