@ordewell/core 0.4.0

package/dist/parsing-RjN9JbyG.d.ts

@@ -0,0 +1,161 @@
+import { h as RunnerId, s as ValidationContext, t as ValidationResult, T as Task } from './Task-1NwmUImI.js';
+
+interface RunnerModeInfo {
+    id: string;
+    label: string;
+    description: string;
+    autonomous?: boolean;
+    safe?: boolean;
+}
+/** The slice of RunnerRegistry this module needs — structural, so nothing here depends on the plugin layer. */
+interface ManifestLookup {
+    getManifest(runner: RunnerId): {
+        modes?: RunnerModeInfo[];
+    } | undefined;
+}
+/**
+ * A runner's modes are declared only in its manifest, never through a service,
+ * so every caller that needs them fuses registry and runner list by hand. This
+ * is that fusion, in one place: the planner prompt, the mode pickers on each
+ * surface, and the runner-change retarget all read modes the same way.
+ *
+ * A runner with no modes maps to `[]` rather than being dropped — callers
+ * distinguish "declares no modes" from "not asked about".
+ */
+declare function runnerModesFrom(registry: ManifestLookup, runners: RunnerId[]): Record<RunnerId, RunnerModeInfo[]>;
+/**
+ * Find the mode ID a runner resolves to under the given toggle state.
+ * Tag-based first (autonomous/safe); falls back to positional last non-plan
+ * if no tag is present on any mode (degrades gracefully on untagged manifests).
+ * Returns undefined if `modes` is empty or undefined.
+ */
+declare function resolveDefaultMode(modes: RunnerModeInfo[] | undefined, autonomousDefault?: boolean): string | undefined;
+/**
+ * Build modes compatible with the current toggle. Plan is excluded from the
+ * build-mode list (it is never a default for implementation tasks). Modes
+ * tagged exclusively for the OPPOSITE toggle are hidden — the LLM cannot see
+ * or select them. A dual-tagged mode (both autonomous + safe) is shown under
+ * either toggle.
+ */
+declare function filteredBuildModes(modes: RunnerModeInfo[], autonomousDefault: boolean): RunnerModeInfo[];
+declare function buildModeGuide(runnerModes: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): string;
+declare function resolveTaskMode(emittedMode: string | undefined, runnerId: RunnerId, runnerModes: Record<RunnerId, RunnerModeInfo[]> | undefined, autonomousDefault?: boolean): string;
+
+/** The envelope key a full plan reply is keyed by: `{"tasks":[...]}`. */
+declare const PLAN_ENVELOPE_KEY = "tasks";
+/** The envelope key a targeted-edits reply is keyed by: `{"taskOps":[...]}`. */
+declare const TASK_OPS_ENVELOPE_KEY = "taskOps";
+/** Thrown when an LLM plan response cannot be parsed into a valid plan. Carries the raw text so callers can log it or retry. */
+declare class PlanParseError extends Error {
+    readonly raw: string;
+    /**
+     * True when the reply was cut off mid-object (output-token limit) rather
+     * than malformed — the two need different repairs: a truncated emission will
+     * be cut at the same point again unless the retry frees context or asks for
+     * terser output.
+     */
+    readonly truncated: boolean;
+    /**
+     * True when the JSON parsed fine and a *shape* rule rejected it. The generic
+     * "could not be parsed as JSON" corrective is a lie for these, so the model
+     * re-sends the same object; a semantic rejection must be repaired by naming
+     * the rule it broke.
+     */
+    readonly semantic: boolean;
+    constructor(message: string, raw: string, opts?: {
+        truncated?: boolean;
+        semantic?: boolean;
+    });
+}
+/**
+ * Strip the noise reasoning models wrap around their answer: markdown code
+ * fences and `<think>…</think>` chain-of-thought blocks (which routinely contain
+ * stray braces that would otherwise derail brace-balancing). Reasoning captured
+ * out-of-band by the service never reaches here, but a model that inlines its
+ * thinking in the content channel still must not corrupt parsing.
+ */
+declare function stripModelNoise(raw: string): string;
+/**
+ * Scan an LLM response for every balanced `{…}` object carrying a `"<key>":`
+ * entry. Strips fences and `<think>` blocks first. A matching object is
+ * skipped over wholesale, so its nested braces don't produce fragment
+ * candidates; non-matching objects are descended into, so a match wrapped in
+ * an unrelated outer object is still found. `fallback` preserves the legacy
+ * behavior for callers with no keyed match: the first balanced object, else
+ * the stripped text so a JSON.parse error still surfaces.
+ */
+declare function extractObjectsWithKey(raw: string, key: string): {
+    matches: string[];
+    fallback: {
+        json: string;
+        balanced: boolean;
+    };
+    sawBrace: boolean;
+    /** An object ran to EOF unclosed — the classic signature of truncated output. */
+    sawUnbalanced: boolean;
+};
+/**
+ * Pull the JSON object out of an LLM response and report whether it was balanced.
+ * Strips fences and `<think>` blocks, then walks every top-level `{…}` and
+ * returns the FIRST one that contains a `"tasks"` key — so a brace appearing
+ * earlier in reasoning (or an unrelated preamble object) can't make us parse the
+ * wrong thing. Falls back to the first balanced object and, failing that, the
+ * first `{` onwards so a genuine `JSON.parse` error still surfaces.
+ */
+declare function extractObjectWithBalance(raw: string): {
+    json: string;
+    balanced: boolean;
+    sawBrace: boolean;
+};
+/**
+ * Pull the JSON object out of an LLM response. Strips markdown code fences and
+ * `<think>` blocks, prefers the object containing a `tasks` key, and tolerates a
+ * prose preamble and trailing prose. Returns the fence-stripped text unchanged
+ * if no `{` is present so the caller's JSON.parse produces a clear failure.
+ */
+declare function extractJsonObject(raw: string): string;
+/** Drop trailing commas before a closing `}` or `]` — a common model quirk. */
+declare function stripTrailingCommas(json: string): string;
+/**
+ * Escape raw control characters that appear INSIDE string literals — budget
+ * models routinely emit multi-line `prompt` strings with literal newlines,
+ * which strict JSON.parse rejects ("bad control character"). Characters
+ * outside strings (formatting whitespace) are left untouched.
+ */
+declare function escapeControlCharsInStrings(json: string): string;
+
+/** A task as seen in a still-streaming plan: its title (possibly partial) and whether its object has closed. */
+interface PartialPlanTask {
+    title: string;
+    status: 'streaming' | 'complete';
+    /** Assigned model label, once it has streamed in — for the live row's chip. */
+    model?: string;
+    /** Task mode ("build"|"plan"), once it has streamed in — for the live row's chip. */
+    mode?: string;
+}
+/**
+ * Parse a partial (still-streaming) plan-JSON string into an ordered list of task
+ * rows for the live progress view. Pure and lenient: it walks the characters of the
+ * `tasks` array, emitting one row per task object once it has opened, with the title
+ * read incrementally and the status flipping to `complete` when the object's brace
+ * closes. The currently-streaming object stays `streaming` even with a partial title.
+ * The React view is a thin renderer over this — it never parses JSON itself.
+ */
+declare function parsePartialPlan(partial: string): PartialPlanTask[];
+
+declare function parsePlanJson(raw: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Task[];
+/**
+ * Whether a reply that failed {@link parsePlanJson} actually LOOKED like a
+ * plan attempt — a balanced tasks-keyed object, or JSON that got cut off.
+ * Distinguishes "the model tried to emit a plan and botched it" (worth a
+ * corrective retry) from prose that merely mentions `"tasks"` (leave alone).
+ */
+declare function looksLikePlanAttempt(raw: string): boolean;
+declare function checkUniqueIds(ctx: ValidationContext): ValidationResult;
+declare function checkNoCycles(ctx: ValidationContext): ValidationResult;
+declare function checkDepsResolve(ctx: ValidationContext): ValidationResult;
+declare function checkImmutableLog(ctx: ValidationContext): ValidationResult;
+declare function checkInProgress(ctx: ValidationContext): ValidationResult;
+declare function validatePlanModification(ctx: ValidationContext): ValidationResult;
+
+export { type ManifestLookup as M, PLAN_ENVELOPE_KEY as P, type RunnerModeInfo as R, TASK_OPS_ENVELOPE_KEY as T, type PartialPlanTask as a, PlanParseError as b, buildModeGuide as c, checkDepsResolve as d, checkImmutableLog as e, checkInProgress as f, checkNoCycles as g, checkUniqueIds as h, escapeControlCharsInStrings as i, extractJsonObject as j, extractObjectWithBalance as k, extractObjectsWithKey as l, filteredBuildModes as m, looksLikePlanAttempt as n, parsePlanJson as o, parsePartialPlan as p, resolveTaskMode as q, resolveDefaultMode as r, runnerModesFrom as s, stripModelNoise as t, stripTrailingCommas as u, validatePlanModification as v };

package/dist/parsing-xpozY5ac.d.mts

@@ -0,0 +1,161 @@
+import { h as RunnerId, s as ValidationContext, t as ValidationResult, T as Task } from './Task-1NwmUImI.mjs';
+
+interface RunnerModeInfo {
+    id: string;
+    label: string;
+    description: string;
+    autonomous?: boolean;
+    safe?: boolean;
+}
+/** The slice of RunnerRegistry this module needs — structural, so nothing here depends on the plugin layer. */
+interface ManifestLookup {
+    getManifest(runner: RunnerId): {
+        modes?: RunnerModeInfo[];
+    } | undefined;
+}
+/**
+ * A runner's modes are declared only in its manifest, never through a service,
+ * so every caller that needs them fuses registry and runner list by hand. This
+ * is that fusion, in one place: the planner prompt, the mode pickers on each
+ * surface, and the runner-change retarget all read modes the same way.
+ *
+ * A runner with no modes maps to `[]` rather than being dropped — callers
+ * distinguish "declares no modes" from "not asked about".
+ */
+declare function runnerModesFrom(registry: ManifestLookup, runners: RunnerId[]): Record<RunnerId, RunnerModeInfo[]>;
+/**
+ * Find the mode ID a runner resolves to under the given toggle state.
+ * Tag-based first (autonomous/safe); falls back to positional last non-plan
+ * if no tag is present on any mode (degrades gracefully on untagged manifests).
+ * Returns undefined if `modes` is empty or undefined.
+ */
+declare function resolveDefaultMode(modes: RunnerModeInfo[] | undefined, autonomousDefault?: boolean): string | undefined;
+/**
+ * Build modes compatible with the current toggle. Plan is excluded from the
+ * build-mode list (it is never a default for implementation tasks). Modes
+ * tagged exclusively for the OPPOSITE toggle are hidden — the LLM cannot see
+ * or select them. A dual-tagged mode (both autonomous + safe) is shown under
+ * either toggle.
+ */
+declare function filteredBuildModes(modes: RunnerModeInfo[], autonomousDefault: boolean): RunnerModeInfo[];
+declare function buildModeGuide(runnerModes: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): string;
+declare function resolveTaskMode(emittedMode: string | undefined, runnerId: RunnerId, runnerModes: Record<RunnerId, RunnerModeInfo[]> | undefined, autonomousDefault?: boolean): string;
+
+/** The envelope key a full plan reply is keyed by: `{"tasks":[...]}`. */
+declare const PLAN_ENVELOPE_KEY = "tasks";
+/** The envelope key a targeted-edits reply is keyed by: `{"taskOps":[...]}`. */
+declare const TASK_OPS_ENVELOPE_KEY = "taskOps";
+/** Thrown when an LLM plan response cannot be parsed into a valid plan. Carries the raw text so callers can log it or retry. */
+declare class PlanParseError extends Error {
+    readonly raw: string;
+    /**
+     * True when the reply was cut off mid-object (output-token limit) rather
+     * than malformed — the two need different repairs: a truncated emission will
+     * be cut at the same point again unless the retry frees context or asks for
+     * terser output.
+     */
+    readonly truncated: boolean;
+    /**
+     * True when the JSON parsed fine and a *shape* rule rejected it. The generic
+     * "could not be parsed as JSON" corrective is a lie for these, so the model
+     * re-sends the same object; a semantic rejection must be repaired by naming
+     * the rule it broke.
+     */
+    readonly semantic: boolean;
+    constructor(message: string, raw: string, opts?: {
+        truncated?: boolean;
+        semantic?: boolean;
+    });
+}
+/**
+ * Strip the noise reasoning models wrap around their answer: markdown code
+ * fences and `<think>…</think>` chain-of-thought blocks (which routinely contain
+ * stray braces that would otherwise derail brace-balancing). Reasoning captured
+ * out-of-band by the service never reaches here, but a model that inlines its
+ * thinking in the content channel still must not corrupt parsing.
+ */
+declare function stripModelNoise(raw: string): string;
+/**
+ * Scan an LLM response for every balanced `{…}` object carrying a `"<key>":`
+ * entry. Strips fences and `<think>` blocks first. A matching object is
+ * skipped over wholesale, so its nested braces don't produce fragment
+ * candidates; non-matching objects are descended into, so a match wrapped in
+ * an unrelated outer object is still found. `fallback` preserves the legacy
+ * behavior for callers with no keyed match: the first balanced object, else
+ * the stripped text so a JSON.parse error still surfaces.
+ */
+declare function extractObjectsWithKey(raw: string, key: string): {
+    matches: string[];
+    fallback: {
+        json: string;
+        balanced: boolean;
+    };
+    sawBrace: boolean;
+    /** An object ran to EOF unclosed — the classic signature of truncated output. */
+    sawUnbalanced: boolean;
+};
+/**
+ * Pull the JSON object out of an LLM response and report whether it was balanced.
+ * Strips fences and `<think>` blocks, then walks every top-level `{…}` and
+ * returns the FIRST one that contains a `"tasks"` key — so a brace appearing
+ * earlier in reasoning (or an unrelated preamble object) can't make us parse the
+ * wrong thing. Falls back to the first balanced object and, failing that, the
+ * first `{` onwards so a genuine `JSON.parse` error still surfaces.
+ */
+declare function extractObjectWithBalance(raw: string): {
+    json: string;
+    balanced: boolean;
+    sawBrace: boolean;
+};
+/**
+ * Pull the JSON object out of an LLM response. Strips markdown code fences and
+ * `<think>` blocks, prefers the object containing a `tasks` key, and tolerates a
+ * prose preamble and trailing prose. Returns the fence-stripped text unchanged
+ * if no `{` is present so the caller's JSON.parse produces a clear failure.
+ */
+declare function extractJsonObject(raw: string): string;
+/** Drop trailing commas before a closing `}` or `]` — a common model quirk. */
+declare function stripTrailingCommas(json: string): string;
+/**
+ * Escape raw control characters that appear INSIDE string literals — budget
+ * models routinely emit multi-line `prompt` strings with literal newlines,
+ * which strict JSON.parse rejects ("bad control character"). Characters
+ * outside strings (formatting whitespace) are left untouched.
+ */
+declare function escapeControlCharsInStrings(json: string): string;
+
+/** A task as seen in a still-streaming plan: its title (possibly partial) and whether its object has closed. */
+interface PartialPlanTask {
+    title: string;
+    status: 'streaming' | 'complete';
+    /** Assigned model label, once it has streamed in — for the live row's chip. */
+    model?: string;
+    /** Task mode ("build"|"plan"), once it has streamed in — for the live row's chip. */
+    mode?: string;
+}
+/**
+ * Parse a partial (still-streaming) plan-JSON string into an ordered list of task
+ * rows for the live progress view. Pure and lenient: it walks the characters of the
+ * `tasks` array, emitting one row per task object once it has opened, with the title
+ * read incrementally and the status flipping to `complete` when the object's brace
+ * closes. The currently-streaming object stays `streaming` even with a partial title.
+ * The React view is a thin renderer over this — it never parses JSON itself.
+ */
+declare function parsePartialPlan(partial: string): PartialPlanTask[];
+
+declare function parsePlanJson(raw: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Task[];
+/**
+ * Whether a reply that failed {@link parsePlanJson} actually LOOKED like a
+ * plan attempt — a balanced tasks-keyed object, or JSON that got cut off.
+ * Distinguishes "the model tried to emit a plan and botched it" (worth a
+ * corrective retry) from prose that merely mentions `"tasks"` (leave alone).
+ */
+declare function looksLikePlanAttempt(raw: string): boolean;
+declare function checkUniqueIds(ctx: ValidationContext): ValidationResult;
+declare function checkNoCycles(ctx: ValidationContext): ValidationResult;
+declare function checkDepsResolve(ctx: ValidationContext): ValidationResult;
+declare function checkImmutableLog(ctx: ValidationContext): ValidationResult;
+declare function checkInProgress(ctx: ValidationContext): ValidationResult;
+declare function validatePlanModification(ctx: ValidationContext): ValidationResult;
+
+export { type ManifestLookup as M, PLAN_ENVELOPE_KEY as P, type RunnerModeInfo as R, TASK_OPS_ENVELOPE_KEY as T, type PartialPlanTask as a, PlanParseError as b, buildModeGuide as c, checkDepsResolve as d, checkImmutableLog as e, checkInProgress as f, checkNoCycles as g, checkUniqueIds as h, escapeControlCharsInStrings as i, extractJsonObject as j, extractObjectWithBalance as k, extractObjectsWithKey as l, filteredBuildModes as m, looksLikePlanAttempt as n, parsePlanJson as o, parsePartialPlan as p, resolveTaskMode as q, resolveDefaultMode as r, runnerModesFrom as s, stripModelNoise as t, stripTrailingCommas as u, validatePlanModification as v };

package/dist/parsing.d.mts

@@ -0,0 +1,2 @@
+export { a as PartialPlanTask, b as PlanParseError, j as extractJsonObject, p as parsePartialPlan, o as parsePlanJson } from './parsing-xpozY5ac.mjs';
+import './Task-1NwmUImI.mjs';

package/dist/parsing.d.ts

@@ -0,0 +1,2 @@
+export { a as PartialPlanTask, b as PlanParseError, j as extractJsonObject, p as parsePartialPlan, o as parsePlanJson } from './parsing-RjN9JbyG.js';
+import './Task-1NwmUImI.js';