@yagni-app/code 0.1.0 → 0.2.0

package/dist/extension/pipeline/scrubSecrets.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Conservative secret redaction for captured command output before it enters
+ * findings, handoffs, or run records (invariant §0.9). The verify gate runs
+ * repo-defined typecheck/test commands whose output can echo connection
+ * strings, tokens, or key material (a failing DB test prints its DATABASE_URL,
+ * a debug line dumps process.env); that text flows into critical findings, the
+ * /go handoff, and the backend run record, so it is scrubbed FIRST.
+ *
+ * This mirrors the backend's `yagniCode/scrubSecrets.ts` pattern set verbatim
+ * (the "existing scrubSecrets path" of spec §3d) — the pipeline cannot import
+ * across packages, so the patterns are duplicated here; keep the two in sync.
+ * Over-redacts rather than under-redacts; pure; never throws.
+ */
+export declare function scrubSecrets(text: string): string;
+//# sourceMappingURL=scrubSecrets.d.ts.map

package/dist/extension/pipeline/scrubSecrets.js

@@ -0,0 +1,32 @@
+/**
+ * Conservative secret redaction for captured command output before it enters
+ * findings, handoffs, or run records (invariant §0.9). The verify gate runs
+ * repo-defined typecheck/test commands whose output can echo connection
+ * strings, tokens, or key material (a failing DB test prints its DATABASE_URL,
+ * a debug line dumps process.env); that text flows into critical findings, the
+ * /go handoff, and the backend run record, so it is scrubbed FIRST.
+ *
+ * This mirrors the backend's `yagniCode/scrubSecrets.ts` pattern set verbatim
+ * (the "existing scrubSecrets path" of spec §3d) — the pipeline cannot import
+ * across packages, so the patterns are duplicated here; keep the two in sync.
+ * Over-redacts rather than under-redacts; pure; never throws.
+ */
+const PATTERNS = [
+    // Credentials embedded in connection-string URLs: scheme://user:password@host
+    // (the password segment has no secret-named key and is usually too short for the
+    // base64 rule, so it would otherwise survive — common in config/env diffs).
+    [/\b([a-z][a-z0-9+.\-]*:\/\/[^\s:@/]+):[^\s:@/]+@/gi, "$1:[REDACTED]@"],
+    // Provider key prefixes (OpenAI, Stripe secret/restricted, GitHub, Slack, AWS access key id, etc.)
+    [/\b(sk-[A-Za-z0-9]{16,}|sk_(?:live|test)_[A-Za-z0-9]{16,}|rk_(?:live|test)_[A-Za-z0-9]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_\-]{20,})\b/g, "[REDACTED]"],
+    // key = "value" / key: value for secret-named keys
+    [/\b([A-Za-z0-9_]*(?:secret|password|passwd|api[_-]?key|token|private[_-]?key|access[_-]?key)[A-Za-z0-9_]*)\b(\s*[:=]\s*)("[^"]+"|'[^']+'|`[^`]+`|[^\s"']+)/gi, "$1$2[REDACTED]"],
+    // Long base64-ish blobs (likely keys/JWTs)
+    [/\b[A-Za-z0-9+/]{40,}={0,2}\b/g, "[REDACTED]"],
+];
+export function scrubSecrets(text) {
+    let out = text;
+    for (const [re, repl] of PATTERNS)
+        out = out.replace(re, repl);
+    return out;
+}
+//# sourceMappingURL=scrubSecrets.js.map

package/dist/extension/pipeline/stages.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The declarative v1 stage list as DATA (spec §3 + §7.4) plus a selector.
+ *
+ * This is control-flow-as-data: map(standard) → plan(peak) →
+ * implement(standard) → review(peak, fanned over 3 lenses) → fix(standard).
+ * Routing follows the judgment, not the typing: the strongest `peak` tier on the
+ * steps that decide-what / catch-wrong (Plan, Review); the `standard` tier on the
+ * execution steps (Map, Implement, Fix). The cheaper `efficient` tier stays a
+ * candidate for Map (its job is compression, not judgment) — the Task 13
+ * `/go-compare --map-tier` eval lane exists to settle that; map moves down-tier
+ * only once a live eval run clears it.
+ *
+ * Peak on judgment is affordable precisely BECAUSE the judgment stages are short
+ * (YAG-380): plan plus the three review lenses is roughly 21c per round on
+ * advanced and 51c on peak, while the token-heavy stages that dominate a run
+ * stay down-tier. Quality of the output is the product, so the strongest model
+ * goes where being wrong is most expensive, not where the tokens are.
+ *
+ * `selectStages(lane)` returns the full list for v1 and is the seam where v2
+ * complexity-lanes plug in without a rewrite.
+ */
+import type { PipelineStage, ReviewLens } from "./types.js";
+/** The three adversarial review angles, fanned out per round (spec §3). */
+export declare const REVIEW_LENSES: ReviewLens[];
+/**
+ * The review lenses the round cannot proceed without (R2 partial-failure
+ * tolerance). When ONE of these is the lens that fails, the round fails honestly
+ * rather than proceeding on a partial review; a non-required lens failing only
+ * degrades the round (the survivors carry it, recorded as `degradedLenses`).
+ * Correctness is load-bearing: a change that might be wrong must never sail
+ * through just because the cheaper lenses passed. Tunable, widen to make another
+ * lens load-bearing.
+ */
+export declare const REQUIRED_LENSES: ReviewLens[];
+export declare const PIPELINE_V1: PipelineStage[];
+/** The single review stage the orchestrator fans out across REVIEW_LENSES. */
+export declare function reviewStage(): PipelineStage;
+/**
+ * Select the stage list for a lane. v1 has exactly one lane ('full'); this is
+ * the identity selector and the extension point for v2 complexity-lanes.
+ */
+export declare function selectStages(_lane?: "full"): PipelineStage[];
+/**
+ * The findings-contract re-ask stage (spec §3e): when a HEALTHY lens returns
+ * non-empty prose with no ```findings fence, the orchestrator re-invokes it
+ * ONCE on the cheap `efficient` tier with this minimal prompt — a pure
+ * format-recovery pass, not a second review. The lens's original output rides
+ * in as `{previous}`. Tools are the minimal REAL list `["read"]`:
+ * `buildStageInvocation` joins `--tools` with a comma, so an empty array would
+ * emit the broken `--tools ""`.
+ */
+export declare function reaskStage(review: PipelineStage): PipelineStage;
+//# sourceMappingURL=stages.d.ts.map

package/dist/extension/pipeline/stages.js

@@ -0,0 +1,115 @@
+/**
+ * The declarative v1 stage list as DATA (spec §3 + §7.4) plus a selector.
+ *
+ * This is control-flow-as-data: map(standard) → plan(peak) →
+ * implement(standard) → review(peak, fanned over 3 lenses) → fix(standard).
+ * Routing follows the judgment, not the typing: the strongest `peak` tier on the
+ * steps that decide-what / catch-wrong (Plan, Review); the `standard` tier on the
+ * execution steps (Map, Implement, Fix). The cheaper `efficient` tier stays a
+ * candidate for Map (its job is compression, not judgment) — the Task 13
+ * `/go-compare --map-tier` eval lane exists to settle that; map moves down-tier
+ * only once a live eval run clears it.
+ *
+ * Peak on judgment is affordable precisely BECAUSE the judgment stages are short
+ * (YAG-380): plan plus the three review lenses is roughly 21c per round on
+ * advanced and 51c on peak, while the token-heavy stages that dominate a run
+ * stay down-tier. Quality of the output is the product, so the strongest model
+ * goes where being wrong is most expensive, not where the tokens are.
+ *
+ * `selectStages(lane)` returns the full list for v1 and is the seam where v2
+ * complexity-lanes plug in without a rewrite.
+ */
+/** The three adversarial review angles, fanned out per round (spec §3). */
+export const REVIEW_LENSES = ["correctness", "business_fit", "does_it_hold"];
+/**
+ * The review lenses the round cannot proceed without (R2 partial-failure
+ * tolerance). When ONE of these is the lens that fails, the round fails honestly
+ * rather than proceeding on a partial review; a non-required lens failing only
+ * degrades the round (the survivors carry it, recorded as `degradedLenses`).
+ * Correctness is load-bearing: a change that might be wrong must never sail
+ * through just because the cheaper lenses passed. Tunable, widen to make another
+ * lens load-bearing.
+ */
+export const REQUIRED_LENSES = ["correctness"];
+/** Read-only recon + grounding tools shared by scout and reviewer. */
+const READ_TOOLS = ["read", "grep", "find", "ls", "bash"];
+/** Full write tools for the worker stages. */
+const WRITE_TOOLS = ["read", "write", "edit", "bash", "grep", "find", "ls"];
+export const PIPELINE_V1 = [
+    {
+        id: "map",
+        agent: "scout",
+        model: "standard",
+        tools: [...READ_TOOLS, "ask_yagni"],
+        taskTemplate: "Map the codebase for this ticket and return a compressed context brief: " +
+            "where the relevant code lives, the conventions in play, and anything " +
+            "ask_yagni surfaces about how this company wants this done.\n\nTicket: {ticket}",
+    },
+    {
+        id: "plan",
+        agent: "planner",
+        model: "peak",
+        // Read-only recon (read/grep/find/ls) so the planner can actually navigate
+        // instead of flailing on a single `read` and ending mid-exploration; NO bash
+        // (it must not build/run), and ask_yagni for grounding.
+        tools: ["read", "grep", "find", "ls", "ask_yagni"],
+        taskTemplate: "Turn the ticket and the repo map into an ordered, grounded implementation " +
+            "plan. Call ask_yagni before inferring a convention.\n\n" +
+            "Ticket: {ticket}\n\nRepo map:\n{previous}",
+    },
+    {
+        id: "implement",
+        agent: "worker",
+        model: "standard",
+        tools: [...WRITE_TOOLS, "ask_yagni", "record_decision"],
+        taskTemplate: "Implement the plan. Write the code against it, and call record_decision " +
+            "for any product-intent call you are forced to make.\n\nPlan:\n{previous}",
+    },
+    {
+        id: "review",
+        agent: "reviewer",
+        model: "peak",
+        tools: [...READ_TOOLS, "ask_yagni", "review_business_match"],
+        taskTemplate: "Review the implementation adversarially. Diff/summary of the change:\n{previous}",
+    },
+    {
+        id: "fix",
+        agent: "worker",
+        model: "standard",
+        tools: [...WRITE_TOOLS, "ask_yagni"],
+        taskTemplate: "Reconcile ONLY the blocking review findings against the plan. Leave " +
+            "non-blocking findings alone.\n\nBlocking findings:\n{previous}",
+    },
+];
+/** The single review stage the orchestrator fans out across REVIEW_LENSES. */
+export function reviewStage() {
+    const stage = PIPELINE_V1.find((s) => s.id === "review");
+    if (!stage)
+        throw new Error("PIPELINE_V1 is missing the review stage");
+    return stage;
+}
+/**
+ * Select the stage list for a lane. v1 has exactly one lane ('full'); this is
+ * the identity selector and the extension point for v2 complexity-lanes.
+ */
+export function selectStages(_lane = "full") {
+    return PIPELINE_V1;
+}
+/**
+ * The findings-contract re-ask stage (spec §3e): when a HEALTHY lens returns
+ * non-empty prose with no ```findings fence, the orchestrator re-invokes it
+ * ONCE on the cheap `efficient` tier with this minimal prompt — a pure
+ * format-recovery pass, not a second review. The lens's original output rides
+ * in as `{previous}`. Tools are the minimal REAL list `["read"]`:
+ * `buildStageInvocation` joins `--tools` with a comma, so an empty array would
+ * emit the broken `--tools ""`.
+ */
+export function reaskStage(review) {
+    return {
+        ...review,
+        model: "efficient",
+        tools: ["read"],
+        taskTemplate: "Re-emit ONLY the ```findings block for the review you just produced:\n{previous}",
+    };
+}
+//# sourceMappingURL=stages.js.map

package/dist/extension/pipeline/ticketResolution.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pre-resolve the /go {ticket} slot to the REAL ticket before planning.
+ *
+ * `/go YAG-234` interpolates the raw arg string into every stage's {ticket}
+ * prompt slot, so without this the scout/planner plan blind on the literal
+ * "YAG-234". This fail-soft helper asks YAGNI to resolve the reference (POST
+ * /api/yagni-code/ask with a structured `ticketRef`), and on a hit returns a
+ * formatted brief carrying the VERBATIM ticket title + description (the
+ * acceptance criteria live inside the body) for the {ticket} slot.
+ *
+ * It is the read-path twin of {@link makeRunSession}'s fetch seam (baseUrl +
+ * injectable getToken + fetchImpl, via resilientFetch). The server resolves the
+ * ticket with a live, workspace-scoped connector READ, never an LLM call, so
+ * this never bills the ask compose path and never risks a model-rewritten body.
+ *
+ * FAIL-SOFT by contract: a non-identifier arg, an unconnected ticket connector,
+ * a miss, or any transport error returns null so /go passes the raw arg through
+ * unchanged (today's honest blind) rather than planning on a wrong body.
+ */
+export interface ResolveTicketBriefOptions {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+    /** Backoff seams threaded into resilientFetch so the retry path is instant under test. */
+    sleep?: (ms: number) => Promise<void>;
+    random?: () => number;
+}
+/**
+ * Resolve a /go arg to a verbatim ticket brief, or null to keep the raw arg.
+ * Never throws; a non-identifier arg short-circuits before any network call.
+ */
+export declare function resolveTicketBrief(opts: ResolveTicketBriefOptions, rawArg: string): Promise<string | null>;
+//# sourceMappingURL=ticketResolution.d.ts.map

package/dist/extension/pipeline/ticketResolution.js

@@ -0,0 +1,75 @@
+/**
+ * Pre-resolve the /go {ticket} slot to the REAL ticket before planning.
+ *
+ * `/go YAG-234` interpolates the raw arg string into every stage's {ticket}
+ * prompt slot, so without this the scout/planner plan blind on the literal
+ * "YAG-234". This fail-soft helper asks YAGNI to resolve the reference (POST
+ * /api/yagni-code/ask with a structured `ticketRef`), and on a hit returns a
+ * formatted brief carrying the VERBATIM ticket title + description (the
+ * acceptance criteria live inside the body) for the {ticket} slot.
+ *
+ * It is the read-path twin of {@link makeRunSession}'s fetch seam (baseUrl +
+ * injectable getToken + fetchImpl, via resilientFetch). The server resolves the
+ * ticket with a live, workspace-scoped connector READ, never an LLM call, so
+ * this never bills the ask compose path and never risks a model-rewritten body.
+ *
+ * FAIL-SOFT by contract: a non-identifier arg, an unconnected ticket connector,
+ * a miss, or any transport error returns null so /go passes the raw arg through
+ * unchanged (today's honest blind) rather than planning on a wrong body.
+ */
+import { DEFAULT_FETCH_POLICY, resilientFetch } from "../resilientFetch.js";
+/** A Linear-style identifier ("YAG-234"); only these are worth a resolve attempt. */
+const IDENTIFIER_RE = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
+/** Format the resolved ticket into the verbatim brief injected into {ticket}. */
+function formatBrief(ticket) {
+    const header = `${ticket.identifier}: ${ticket.title}`;
+    const body = (ticket.description ?? "").trim();
+    return body.length > 0 ? `${header}\n\n${body}` : header;
+}
+/**
+ * Resolve a /go arg to a verbatim ticket brief, or null to keep the raw arg.
+ * Never throws; a non-identifier arg short-circuits before any network call.
+ */
+export async function resolveTicketBrief(opts, rawArg) {
+    const ref = rawArg.trim();
+    // Only an identifier-shaped arg is a ticket reference; free-text task
+    // descriptions pass straight through so /go uses them verbatim.
+    if (!IDENTIFIER_RE.test(ref))
+        return null;
+    let res;
+    try {
+        res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/ask`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${opts.getToken() ?? ""}`,
+            },
+            body: JSON.stringify({ ticketRef: ref }),
+        }, {
+            fetchImpl: opts.fetchImpl,
+            policy: DEFAULT_FETCH_POLICY,
+            ...(opts.signal ? { signal: opts.signal } : {}),
+            ...(opts.sleep ? { sleep: opts.sleep } : {}),
+            ...(opts.random ? { random: opts.random } : {}),
+        });
+    }
+    catch {
+        // Unreachable backend after retries: degrade to blind (raw arg).
+        return null;
+    }
+    if (!res.ok)
+        return null;
+    let data;
+    try {
+        data = (await res.json());
+    }
+    catch {
+        return null;
+    }
+    const ticket = data.ticket;
+    if (!ticket || typeof ticket.identifier !== "string" || typeof ticket.title !== "string") {
+        return null;
+    }
+    return formatBrief(ticket);
+}
+//# sourceMappingURL=ticketResolution.js.map