lacuna-cli 0.1.1

package/dist/agent/generator.js

@@ -0,0 +1,220 @@
+import { createProvider } from '../lib/providers/index.js';
+import { buildSystemPrompt, buildGeneratePrompt, buildFixPrompt, buildRetryPrompt } from './prompts.js';
+// Thrown when the model's output was cut off before </code_output> was emitted.
+// The partial code is attached so callers can include it in the retry message.
+export class TruncatedOutputError extends Error {
+    partialCode;
+    constructor(partialCode) {
+        super('Model output was truncated before the response was complete.');
+        this.partialCode = partialCode;
+        this.name = 'TruncatedOutputError';
+    }
+}
+export class OscillationError extends Error {
+    constructor() {
+        super('Agent detected a loop — the generated code is identical to a previous attempt.');
+        this.name = 'OscillationError';
+    }
+}
+const GENERATE_TEMPERATURE = 0.4; // some creativity to match existing patterns
+const RETRY_TEMPERATURE = 0.1; // precise and deterministic when fixing errors
+// Wraps a token callback so that <thinking> content is suppressed.
+// Buffers silently until <code_output> is seen, then streams from there.
+// Falls back to streaming everything if <code_output> never appears (e.g. non-XML response).
+function codeOnlyStream(onToken) {
+    let buf = '';
+    let streaming = false;
+    return (token) => {
+        if (streaming) {
+            onToken(token);
+            return;
+        }
+        buf += token;
+        const idx = buf.indexOf('<code_output>');
+        if (idx !== -1) {
+            streaming = true;
+            const after = buf.slice(idx + '<code_output>'.length);
+            if (after)
+                onToken(after);
+            buf = '';
+            return;
+        }
+        // If no <code_output> after 3000 chars the model skipped the XML wrapper — flush and stream
+        if (buf.length > 3000) {
+            streaming = true;
+            onToken(buf);
+            buf = '';
+        }
+    };
+}
+function normalizeCode(code) {
+    return code.replace(/\s+/g, '');
+}
+const TRUNCATION_RETRY_MESSAGE = 'Your previous output was cut off before the code was complete (unmatched braces or incomplete expression detected). ' +
+    'Write a shorter, more focused test file. Cover the most important behaviors only — skip exhaustive edge cases if needed. ' +
+    'Every function body must be closed.';
+// Detect syntactically incomplete code — a strong signal that output was cut off mid-generation.
+function isCodeIncomplete(code) {
+    if (!code.trim())
+        return true;
+    // Strip string literals to avoid false positives from braces inside strings
+    const stripped = code
+        .replace(/`(?:[^`\\]|\\.)*`/gs, '``')
+        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+        .replace(/'(?:[^'\\]|\\.)*'/g, "''");
+    // Unmatched opening braces (allow +1 tolerance for edge cases)
+    const opens = (stripped.match(/\{/g) ?? []).length;
+    const closes = (stripped.match(/\}/g) ?? []).length;
+    if (opens > closes + 1)
+        return true;
+    // Last meaningful character suggests an incomplete expression
+    const lastChar = code.trimEnd().slice(-1);
+    if (',(=+-&|?:'.includes(lastChar))
+        return true;
+    return false;
+}
+// Parse the structured <thinking> + <code_output> response.
+// The stop sequence </code_output> is registered with the API, so the closing tag
+// is normally absent from the raw response — that is a clean stop, not truncation.
+// True truncation (model hit max_tokens mid-code) is detected syntactically.
+function parseStructuredResponse(raw) {
+    const thinkingMatch = raw.match(/<thinking>([\s\S]*?)<\/thinking>/i);
+    const hypothesis = thinkingMatch ? thinkingMatch[1].trim() : '';
+    // Closed tag present (stop sequence not in effect, or model included it anyway)
+    const codeMatch = raw.match(/<code_output>([\s\S]*?)<\/code_output>/i);
+    if (codeMatch) {
+        const code = codeMatch[1].trim();
+        return { hypothesis, code, truncated: isCodeIncomplete(code) };
+    }
+    // Opening tag present, no closing tag — normal when stop sequence fires cleanly
+    const openIdx = raw.search(/<code_output>/i);
+    if (openIdx !== -1) {
+        const code = raw.slice(openIdx + '<code_output>'.length).trim();
+        return { hypothesis, code, truncated: isCodeIncomplete(code) };
+    }
+    // No XML tags — extract the last fenced code block if present.
+    // Gemini and other models sometimes emit prose + multiple draft blocks before
+    // settling on a final answer; the last block is the intended output.
+    const fenceMatches = [...raw.matchAll(/```(?:typescript|tsx?|javascript|jsx?|python|go)?\s*\n([\s\S]*?)```/g)];
+    if (fenceMatches.length > 0) {
+        const code = fenceMatches[fenceMatches.length - 1][1].trim();
+        return { hypothesis, code, truncated: isCodeIncomplete(code) };
+    }
+    // No fenced blocks at all — strip any single fence pair and use as code
+    let fallback = raw.trim();
+    fallback = fallback.replace(/^```(?:typescript|tsx?|javascript|jsx?|python|go)?\s*\n/, '');
+    fallback = fallback.replace(/\n```\s*$/, '');
+    const code = fallback.trim();
+    return { hypothesis, code, truncated: isCodeIncomplete(code) };
+}
+export class TestGenerator {
+    provider;
+    env;
+    rawOnToken; // unwrapped callback; filter recreated per call
+    maxTokens;
+    history = [];
+    lastHypothesis = '';
+    failedAttempts = [];
+    previousCodes = []; // normalized codes from all attempts, for oscillation detection
+    constructor(options) {
+        this.provider = createProvider(options.config);
+        this.env = options.env;
+        this.rawOnToken = options.onToken;
+        this.maxTokens = options.config.maxTokens ?? 16000;
+    }
+    // Swap the token callback between files (e.g. to attach a StreamingFileViewer per file).
+    // A fresh codeOnlyStream filter is created on every generate/fix/retry call anyway,
+    // so calling this resets streaming state automatically.
+    setTokenCallback(cb) {
+        this.rawOnToken = cb;
+    }
+    async generate(context, gap, projectMemory) {
+        this.lastHypothesis = '';
+        this.failedAttempts = [];
+        this.previousCodes = [];
+        this.history = [
+            {
+                role: 'user',
+                content: buildGeneratePrompt({
+                    sourceFile: context.sourceFile,
+                    sourceCode: context.sourceCode,
+                    existingTestCode: context.existingTestCode,
+                    uncoveredFunctions: gap.uncoveredFunctions,
+                    uncoveredLines: gap.uncoveredLines,
+                    env: this.env,
+                    sourceImportPath: context.sourceImportPath,
+                    mocksCode: context.mocksCode,
+                    mocksImportPath: context.mocksImportPath,
+                    setupFileCode: context.setupFileCode,
+                    packageDeps: context.packageDeps,
+                    tsconfigPaths: context.tsconfigPaths,
+                    typeDefinitions: context.typeDefinitions,
+                    localImportPaths: context.localImportPaths,
+                    reactMajorVersion: context.reactMajorVersion,
+                    projectMemory,
+                }),
+            },
+        ];
+        const response = await this.provider.generate(this.history, buildSystemPrompt(this.env), this.rawOnToken ? codeOnlyStream(this.rawOnToken) : undefined, this.maxTokens, GENERATE_TEMPERATURE);
+        const { hypothesis, code, truncated } = parseStructuredResponse(response);
+        this.lastHypothesis = hypothesis;
+        this.previousCodes.push(normalizeCode(code));
+        this.history.push({ role: 'assistant', content: response });
+        if (truncated)
+            throw new TruncatedOutputError(code);
+        return code;
+    }
+    async fix(args) {
+        this.lastHypothesis = '';
+        this.failedAttempts = [];
+        this.previousCodes = [];
+        this.history = [{ role: 'user', content: buildFixPrompt(args) }];
+        const response = await this.provider.generate(this.history, buildSystemPrompt(this.env), this.rawOnToken ? codeOnlyStream(this.rawOnToken) : undefined, this.maxTokens, GENERATE_TEMPERATURE);
+        const { hypothesis, code, truncated } = parseStructuredResponse(response);
+        this.lastHypothesis = hypothesis;
+        this.previousCodes.push(normalizeCode(code));
+        this.history.push({ role: 'assistant', content: response });
+        if (truncated)
+            throw new TruncatedOutputError(code);
+        return code;
+    }
+    async retry(failureOutput) {
+        // Record what the previous attempt planned and why it failed
+        this.failedAttempts.push({
+            attemptNumber: this.failedAttempts.length + 1,
+            hypothesis: this.lastHypothesis,
+            failureReason: failureOutput,
+        });
+        // Trim history to: original prompt + latest code + new retry message
+        // This keeps memory flat regardless of iteration count.
+        const original = this.history[0];
+        let latestCode;
+        for (let i = this.history.length - 1; i >= 0; i--) {
+            if (this.history[i].role === 'assistant') {
+                latestCode = this.history[i];
+                break;
+            }
+        }
+        this.history = latestCode && latestCode !== original
+            ? [original, latestCode]
+            : [original];
+        this.history.push({
+            role: 'user',
+            content: buildRetryPrompt(failureOutput, this.failedAttempts),
+        });
+        const response = await this.provider.generate(this.history, buildSystemPrompt(this.env), this.rawOnToken ? codeOnlyStream(this.rawOnToken) : undefined, this.maxTokens, RETRY_TEMPERATURE);
+        const { hypothesis, code, truncated } = parseStructuredResponse(response);
+        this.lastHypothesis = hypothesis;
+        this.history.push({ role: 'assistant', content: response });
+        if (truncated)
+            throw new TruncatedOutputError(code);
+        // Oscillation check: if this code is identical to any prior attempt, break early
+        const norm = normalizeCode(code);
+        if (this.previousCodes.includes(norm))
+            throw new OscillationError();
+        this.previousCodes.push(norm);
+        return code;
+    }
+}
+export { TRUNCATION_RETRY_MESSAGE };
+//# sourceMappingURL=generator.js.map

package/dist/agent/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../src/agent/generator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAKvG,gFAAgF;AAChF,+EAA+E;AAC/E,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IACjB;IAA5B,YAA4B,WAAmB;QAC7C,KAAK,CAAC,8DAA8D,CAAC,CAAA;QAD3C,gBAAW,GAAX,WAAW,CAAQ;QAE7C,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAA;IACpC,CAAC;CACF;AAED,MAAM,OAAO,gBAAiB,SAAQ,KAAK;IACzC;QACE,KAAK,CAAC,gFAAgF,CAAC,CAAA;QACvF,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAA;IAChC,CAAC;CACF;AAED,MAAM,oBAAoB,GAAG,GAAG,CAAA,CAAE,6CAA6C;AAC/E,MAAM,iBAAiB,GAAG,GAAG,CAAA,CAAK,+CAA+C;AAEjF,mEAAmE;AACnE,yEAAyE;AACzE,6FAA6F;AAC7F,SAAS,cAAc,CAAC,OAA4B;IAClD,IAAI,GAAG,GAAG,EAAE,CAAA;IACZ,IAAI,SAAS,GAAG,KAAK,CAAA;IACrB,OAAO,CAAC,KAAa,EAAE,EAAE;QACvB,IAAI,SAAS,EAAE,CAAC;YAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAAC,OAAM;QAAC,CAAC;QACzC,GAAG,IAAI,KAAK,CAAA;QACZ,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;QACxC,IAAI,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC;YACf,SAAS,GAAG,IAAI,CAAA;YAChB,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,eAAe,CAAC,MAAM,CAAC,CAAA;YACrD,IAAI,KAAK;gBAAE,OAAO,CAAC,KAAK,CAAC,CAAA;YACzB,GAAG,GAAG,EAAE,CAAA;YACR,OAAM;QACR,CAAC;QACD,4FAA4F;QAC5F,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;YAAC,SAAS,GAAG,IAAI,CAAC;YAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAAC,GAAG,GAAG,EAAE,CAAA;QAAC,CAAC;IACrE,CAAC,CAAA;AACH,CAAC;AAED,SAAS,aAAa,CAAC,IAAY;IACjC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;AACjC,CAAC;AAQD,MAAM,wBAAwB,GAC5B,sHAAsH;IACtH,2HAA2H;IAC3H,qCAAqC,CAAA;AAEvC,iGAAiG;AACjG,SAAS,gBAAgB,CAAC,IAAY;IACpC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;QAAE,OAAO,IAAI,CAAA;IAE7B,4EAA4E;IAC5E,MAAM,QAAQ,GAAG,IAAI;SAClB,OAAO,CAAC,qBAAqB,EAAE,IAAI,CAAC;SACpC,OAAO,CAAC,oBAAoB,EAAE,IAAI,CAAC;SACnC,OAAO,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAA;IAEtC,+DAA+D;IAC/D,MAAM,KAAK,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAA;IAClD,MAAM,MAAM,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAA;IACnD,IAAI,KAAK,GAAG,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAA;IAEnC,8DAA8D;IAC9D,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;IACzC,IAAI,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAA;IAE/C,OAAO,KAAK,CAAA;AACd,CAAC;AAED,4DAA4D;AAC5D,kFAAkF;AAClF,mFAAmF;AACnF,6EAA6E;AAC7E,SAAS,uBAAuB,CAAC,GAAW;IAC1C,MAAM,aAAa,GAAG,GAAG,CAAC,KAAK,CAAC,mCAAmC,CAAC,CAAA;IACpE,MAAM,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IAE/D,gFAAgF;IAChF,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,yCAAyC,CAAC,CAAA;IACtE,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;QAChC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAA;IAChE,CAAC;IAED,gFAAgF;IAChF,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAA;IAC5C,IAAI,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,OAAO,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAA;QAC/D,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAA;IAChE,CAAC;IAED,+DAA+D;IAC/D,8EAA8E;IAC9E,qEAAqE;IACrE,MAAM,YAAY,GAAG,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,sEAAsE,CAAC,CAAC,CAAA;IAC9G,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,YAAY,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;QAC5D,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAA;IAChE,CAAC;IACD,wEAAwE;IACxE,IAAI,QAAQ,GAAG,GAAG,CAAC,IAAI,EAAE,CAAA;IACzB,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,yDAAyD,EAAE,EAAE,CAAC,CAAA;IAC1F,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAA;IAC5C,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAA;IAC5B,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAA;AAChE,CAAC;AAED,MAAM,OAAO,aAAa;IAChB,QAAQ,CAAe;IACvB,GAAG,CAAqB;IACxB,UAAU,CAA0B,CAAG,gDAAgD;IACvF,SAAS,CAAQ;IACjB,OAAO,GAAkB,EAAE,CAAA;IAC3B,cAAc,GAAW,EAAE,CAAA;IAC3B,cAAc,GAAoB,EAAE,CAAA;IACpC,aAAa,GAAa,EAAE,CAAA,CAAE,gEAAgE;IAEtG,YAAY,OAAyB;QACnC,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QAC9C,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAA;QACtB,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,OAAO,CAAA;QACjC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,IAAI,KAAK,CAAA;IACpD,CAAC;IAED,yFAAyF;IACzF,oFAAoF;IACpF,wDAAwD;IACxD,gBAAgB,CAAC,EAAyC;QACxD,IAAI,CAAC,UAAU,GAAG,EAAE,CAAA;IACtB,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,OAAoB,EAAE,GAAgB,EAAE,aAA6B;QAClF,IAAI,CAAC,cAAc,GAAG,EAAE,CAAA;QACxB,IAAI,CAAC,cAAc,GAAG,EAAE,CAAA;QACxB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAA;QAEvB,IAAI,CAAC,OAAO,GAAG;YACb;gBACE,IAAI,EAAE,MAAM;gBACZ,OAAO,EAAE,mBAAmB,CAAC;oBAC3B,UAAU,EAAE,OAAO,CAAC,UAAU;oBAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;oBAC9B,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;oBAC1C,kBAAkB,EAAE,GAAG,CAAC,kBAAkB;oBAC1C,cAAc,EAAE,GAAG,CAAC,cAAc;oBAClC,GAAG,EAAE,IAAI,CAAC,GAAG;oBACb,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;oBAC1C,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,eAAe,EAAE,OAAO,CAAC,eAAe;oBACxC,aAAa,EAAE,OAAO,CAAC,aAAa;oBACpC,WAAW,EAAE,OAAO,CAAC,WAAW;oBAChC,aAAa,EAAE,OAAO,CAAC,aAAa;oBACpC,eAAe,EAAE,OAAO,CAAC,eAAe;oBACxC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;oBAC1C,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;oBAC5C,aAAa;iBACd,CAAC;aACH;SACF,CAAA;QAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAC3C,IAAI,CAAC,OAAO,EACZ,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,EAC3B,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,EAC7D,IAAI,CAAC,SAAS,EACd,oBAAoB,CACrB,CAAA;QACD,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAA;QACzE,IAAI,CAAC,cAAc,GAAG,UAAU,CAAA;QAChC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAA;QAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAA;QAC3D,IAAI,SAAS;YAAE,MAAM,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAA;QACnD,OAAO,IAAI,CAAA;IACb,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,IAA0C;QAClD,IAAI,CAAC,cAAc,GAAG,EAAE,CAAA;QACxB,IAAI,CAAC,cAAc,GAAG,EAAE,CAAA;QACxB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAA;QAEvB,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QAChE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAC3C,IAAI,CAAC,OAAO,EACZ,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,EAC3B,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,EAC7D,IAAI,CAAC,SAAS,EACd,oBAAoB,CACrB,CAAA;QACD,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAA;QACzE,IAAI,CAAC,cAAc,GAAG,UAAU,CAAA;QAChC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAA;QAC5C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAA;QAC3D,IAAI,SAAS;YAAE,MAAM,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAA;QACnD,OAAO,IAAI,CAAA;IACb,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,aAAqB;QAC/B,6DAA6D;QAC7D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;YACvB,aAAa,EAAE,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC;YAC7C,UAAU,EAAE,IAAI,CAAC,cAAc;YAC/B,aAAa,EAAE,aAAa;SAC7B,CAAC,CAAA;QAEF,qEAAqE;QACrE,wDAAwD;QACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;QAChC,IAAI,UAAmC,CAAA;QACvC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAClD,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gBAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAAC,MAAK;YAAC,CAAC;QACnF,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,UAAU,IAAI,UAAU,KAAK,QAAQ;YAClD,CAAC,CAAC,CAAC,QAAQ,EAAE,UAAU,CAAC;YACxB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAA;QAEd,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE,gBAAgB,CAAC,aAAa,EAAE,IAAI,CAAC,cAAc,CAAC;SAC9D,CAAC,CAAA;QAEF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAC3C,IAAI,CAAC,OAAO,EACZ,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,EAC3B,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,EAC7D,IAAI,CAAC,SAAS,EACd,iBAAiB,CAClB,CAAA;QACD,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAA;QACzE,IAAI,CAAC,cAAc,GAAG,UAAU,CAAA;QAChC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAA;QAC3D,IAAI,SAAS;YAAE,MAAM,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAA;QAEnD,iFAAiF;QACjF,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,CAAA;QAChC,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,MAAM,IAAI,gBAAgB,EAAE,CAAA;QACnE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAE7B,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AAED,OAAO,EAAE,wBAAwB,EAAE,CAAA"}

package/dist/agent/loop.d.ts

@@ -0,0 +1,23 @@
+import type { LacunaConfig } from '../lib/config.js';
+import type { DetectedEnvironment } from '../lib/detector.js';
+export interface LoopOptions {
+    config: LacunaConfig;
+    env: DetectedEnvironment;
+    cwd: string;
+    dryRun: boolean;
+    verbose: boolean;
+    targetFile?: string;
+    workers?: number;
+    fresh?: boolean;
+    log: (msg: string) => void;
+}
+export interface LoopResult {
+    filesProcessed: number;
+    testsWritten: number;
+    coverageBefore: number;
+    coverageAfter: number;
+    hasCoverage: boolean;
+    errors: string[];
+}
+export declare function runAgentLoop(options: LoopOptions): Promise<LoopResult>;
+//# sourceMappingURL=loop.d.ts.map

package/dist/agent/loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAiB7D,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,YAAY,CAAA;IACpB,GAAG,EAAE,mBAAmB,CAAA;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3B;AAED,MAAM,WAAW,UAAU;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AA6QD,wBAAsB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAyJ5E"}

package/dist/agent/loop.js

@@ -0,0 +1,394 @@
+import { writeFile, mkdir, readFile, unlink } from 'fs/promises';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+import { fileTestCommand } from '../lib/detector.js';
+import { runCommand } from '../lib/runner.js';
+import { loadCoverage, coverageAgeSeconds, extractGaps, filterTestableGaps, findUncoveredFiles } from '../lib/coverage/index.js';
+import { WorkerDisplay } from '../lib/worker-display.js';
+import { startCoverageSpinner } from '../lib/coverage-spinner.js';
+import { buildFileContext } from './context.js';
+import { TestGenerator, TruncatedOutputError, OscillationError, TRUNCATION_RETRY_MESSAGE } from './generator.js';
+import { ProjectMemory } from './project-memory.js';
+import { getActiveTips, createTipRotator, formatTip } from '../lib/tips.js';
+import { typeCheckFile } from '../lib/typecheck.js';
+import { hasTestFunctions, enrichNoTestsError, isZeroTestsOutput, parsePassCount, buildStructureBrokenMessage, buildRegressionMessage } from '../lib/validate.js';
+import { extractTestFailure } from '../lib/extract-error.js';
+import { StreamingFileViewer } from '../lib/streaming-viewer.js';
+async function getCoverageRate(config, cwd) {
+    try {
+        const report = await loadCoverage(config, cwd);
+        return report.totalLineRate * 100;
+    }
+    catch {
+        return 0;
+    }
+}
+async function processGap(gap, options, generator, parallel, onStatus, projectMemory) {
+    const { config, env, cwd, dryRun, verbose, log } = options;
+    const shortPath = gap.filePath.replace(cwd + '/', '');
+    if (!onStatus) {
+        log(chalk.bold(`\n  Processing: ${chalk.cyan(shortPath)}`));
+        if (gap.uncoveredFunctions.length > 0) {
+            log(chalk.dim(`  Uncovered functions: ${gap.uncoveredFunctions.join(', ')}`));
+        }
+    }
+    let context;
+    try {
+        context = await buildFileContext(gap.filePath.replace(cwd + '/', ''), cwd, env, config);
+    }
+    catch {
+        const msg = `Could not read source file: ${gap.filePath}`;
+        if (!onStatus)
+            log(chalk.red(`  ${msg}`));
+        onStatus?.({ phase: 'failed', file: shortPath });
+        return { success: false, error: msg };
+    }
+    if (!onStatus) {
+        log(chalk.dim(`  ${context.existingTestFile ? 'Updating' : 'Creating'}: ${context.suggestedTestFile.replace(cwd + '/', '')}`));
+    }
+    // parallel: run only this test file so workers don't race on the full suite
+    const testCmd = parallel
+        ? fileTestCommand(env, context.suggestedTestFile)
+        : env.testCommand;
+    // Capture pre-existing test file so we can restore on failure
+    let originalTestContent = null;
+    if (!dryRun) {
+        try {
+            originalTestContent = await readFile(context.suggestedTestFile, 'utf-8');
+        }
+        catch { /* new file */ }
+    }
+    let generatedCode = null;
+    let lastError = null;
+    let firstError = null; // error from attempt 1, kept as anchor for regressions
+    let firstPassCount = 0; // passing tests on attempt 1
+    for (let attempt = 1; attempt <= config.maxIterations; attempt++) {
+        if (!onStatus) {
+            if (attempt > 1) {
+                log(chalk.yellow(`\n  Retry ${attempt}/${config.maxIterations} — fixing failures...`));
+            }
+            else {
+                log(chalk.dim(`\n  Generating tests via ${config.model}...`));
+            }
+        }
+        onStatus?.({
+            phase: attempt === 1 ? 'generating' : 'retrying',
+            file: shortPath,
+            ...(attempt > 1 ? { attempt, max: config.maxIterations } : {}),
+        });
+        let viewer;
+        if (verbose && !onStatus) {
+            viewer = new StreamingFileViewer(shortPath);
+            generator.setTokenCallback(t => viewer.append(t));
+            viewer.start();
+        }
+        try {
+            generatedCode = attempt === 1
+                ? await generator.generate(context, gap, projectMemory)
+                : await generator.retry(lastError ?? '');
+        }
+        catch (err) {
+            viewer?.stop();
+            generator.setTokenCallback(undefined);
+            if (err instanceof TruncatedOutputError) {
+                lastError = TRUNCATION_RETRY_MESSAGE;
+                if (!onStatus)
+                    log(chalk.yellow(`\n  Output truncated — retrying with shorter output request...`));
+                onStatus?.({ phase: 'retrying', file: shortPath, attempt, max: config.maxIterations });
+                continue;
+            }
+            if (err instanceof OscillationError) {
+                if (!onStatus)
+                    log(chalk.red(`\n  ⚠ Agent loop detected — output identical to a previous attempt. Stopping early.`));
+                onStatus?.({ phase: 'failed', file: shortPath });
+                await restoreTestFile(context.suggestedTestFile, originalTestContent);
+                return { success: false, error: err.message };
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!onStatus)
+                log(chalk.red(`\n  API error: ${msg}`));
+            onStatus?.({ phase: 'failed', file: shortPath });
+            return { success: false, error: msg };
+        }
+        viewer?.stop();
+        generator.setTokenCallback(undefined);
+        if (dryRun) {
+            if (!onStatus) {
+                log(chalk.yellow('\n  [dry-run] Would write:'));
+                log(chalk.dim(generatedCode.split('\n').slice(0, 10).map((l) => `    ${l}`).join('\n')));
+                if (generatedCode.split('\n').length > 10)
+                    log(chalk.dim('    …'));
+            }
+            onStatus?.({ phase: 'passed', file: shortPath });
+            return { success: true, testCode: generatedCode };
+        }
+        const MOCKS_SEPARATOR = '// ---MOCKS_FILE---';
+        let testCode = generatedCode;
+        if (generatedCode.includes(MOCKS_SEPARATOR) && config.mocksFile) {
+            const [newTestCode, newMocksCode] = generatedCode.split(MOCKS_SEPARATOR);
+            testCode = newTestCode.trim();
+            if (newMocksCode?.trim()) {
+                const absoluteMocksFile = join(cwd, config.mocksFile);
+                await mkdir(dirname(absoluteMocksFile), { recursive: true });
+                await writeFile(absoluteMocksFile, newMocksCode.trim(), 'utf-8');
+                if (!onStatus)
+                    log(chalk.dim(`  Updated mocks file: ${config.mocksFile}`));
+            }
+        }
+        // Catch empty test files before writing — no point running a file with no tests
+        if (!hasTestFunctions(testCode)) {
+            lastError =
+                'ERROR: The code you wrote contains NO test functions (no it() or test() calls).\n' +
+                    'Do not write a file with only imports, types, describe() blocks, or helper functions.\n' +
+                    'Every test file must contain at least one: it(\'description\', () => { expect(...).toBe(...) })\n' +
+                    'Rewrite the file and include real test cases.';
+            if (!onStatus)
+                log(chalk.yellow(`  Generated file has no tests — retrying...`));
+            onStatus?.({ phase: 'retrying', file: shortPath, attempt, max: config.maxIterations });
+            continue;
+        }
+        onStatus?.({ phase: 'writing', file: shortPath });
+        await mkdir(dirname(context.suggestedTestFile), { recursive: true });
+        await writeFile(context.suggestedTestFile, testCode, 'utf-8');
+        if (!onStatus)
+            log(chalk.dim(`  Written. Running tests...`));
+        onStatus?.({ phase: 'running', file: shortPath });
+        const runResult = await runCommand(testCmd, cwd);
+        if (runResult.success) {
+            const typeErrors = await typeCheckFile(context.suggestedTestFile, cwd, env);
+            if (typeErrors) {
+                lastError = `Tests passed but TypeScript type errors were found in the generated file:\n${typeErrors}\n\nFix ALL type errors. Do not use 'as any' or '@ts-ignore'.`;
+                if (!onStatus)
+                    log(chalk.yellow(`  Type errors found — retrying...`));
+                onStatus?.({ phase: 'retrying', file: shortPath, attempt, max: config.maxIterations });
+                continue;
+            }
+            if (!onStatus)
+                log(chalk.green(`  Tests passed.`));
+            onStatus?.({ phase: 'passed', file: shortPath });
+            return { success: true, testCode };
+        }
+        const rawRunOutput = runResult.stdout + '\n' + runResult.stderr;
+        const extracted = enrichNoTestsError(extractTestFailure(rawRunOutput));
+        const passCount = parsePassCount(rawRunOutput);
+        if (attempt === 1) {
+            firstError = extracted;
+            firstPassCount = passCount;
+            lastError = extracted;
+            if (!onStatus)
+                log(chalk.red(`  Tests failed (attempt ${attempt}/${config.maxIterations})`));
+        }
+        else if (isZeroTestsOutput(rawRunOutput)) {
+            lastError = buildStructureBrokenMessage(firstError, extracted);
+            if (!onStatus)
+                log(chalk.red(`  Fix broke file structure — 0 tests collected (attempt ${attempt}/${config.maxIterations})`));
+        }
+        else if (passCount < firstPassCount) {
+            lastError = buildRegressionMessage(firstError, extracted, firstPassCount, passCount);
+            if (!onStatus)
+                log(chalk.red(`  Fix caused regression: ${firstPassCount} → ${passCount} passing (attempt ${attempt}/${config.maxIterations})`));
+        }
+        else {
+            lastError = extracted;
+            if (!onStatus)
+                log(chalk.red(`  Tests failed (attempt ${attempt}/${config.maxIterations})`));
+        }
+        if (!onStatus && verbose)
+            log(chalk.dim(lastError.split('\n').slice(0, 20).join('\n')));
+    }
+    onStatus?.({ phase: 'failed', file: shortPath });
+    await restoreTestFile(context.suggestedTestFile, originalTestContent);
+    return {
+        success: false,
+        error: `Tests still failing after ${config.maxIterations} attempts. Last error:\n${lastError?.slice(0, 1500)}`,
+    };
+}
+async function restoreTestFile(testPath, original) {
+    try {
+        if (original !== null) {
+            await writeFile(testPath, original, 'utf-8');
+        }
+        else {
+            await unlink(testPath);
+        }
+    }
+    catch { /* best-effort */ }
+}
+async function runWorkerPool(gaps, options, workerCount, projectMemory) {
+    const tips = getActiveTips({
+        workers: workerCount,
+        targetFile: options.targetFile,
+        verbose: options.verbose,
+        dryRun: options.dryRun,
+        fresh: options.fresh,
+        model: options.config.model,
+        threshold: options.config.threshold,
+        mocksFile: options.config.mocksFile,
+        ignore: options.config.ignore,
+        command: 'generate',
+    });
+    const display = new WorkerDisplay(workerCount, gaps.length, tips);
+    const queue = [...gaps];
+    let filesProcessed = 0;
+    let testsWritten = 0;
+    const errors = [];
+    display.start();
+    const workers = Array.from({ length: workerCount }, async (_, wi) => {
+        const generator = new TestGenerator({
+            config: options.config,
+            env: options.env,
+            // suppress token streaming in parallel mode — display is the UI
+        });
+        while (true) {
+            const gap = queue.shift();
+            if (!gap)
+                break;
+            const onStatus = (state) => display.update(wi, state);
+            const result = await processGap(gap, { ...options, log: () => { }, verbose: false }, generator, true, onStatus, projectMemory);
+            filesProcessed++;
+            if (result.success)
+                testsWritten++;
+            else if (result.error)
+                errors.push(result.error);
+        }
+    });
+    await Promise.all(workers);
+    display.finish();
+    return { filesProcessed, testsWritten, errors };
+}
+// Coverage report is considered fresh for 10 minutes — lets `analyze` then `generate` share one run.
+const COVERAGE_CACHE_TTL_S = 600;
+export async function runAgentLoop(options) {
+    const { config, env, cwd, log } = options;
+    const workerCount = Math.max(1, Math.min(options.workers ?? 1, 10));
+    const parallel = workerCount > 1;
+    // ─── Single-file fast path ────────────────────────────────────────────────────
+    // Skip the coverage suite entirely. Build a synthetic gap that treats the whole
+    // file as uncovered — the AI reads the source and writes comprehensive tests.
+    // Uses fileTestCommand (not the full suite) to verify the generated tests pass.
+    if (options.targetFile) {
+        const abs = options.targetFile.startsWith('/')
+            ? options.targetFile
+            : join(cwd, options.targetFile);
+        const gap = {
+            filePath: abs,
+            uncoveredLines: [],
+            uncoveredFunctions: [],
+        };
+        const memory = new ProjectMemory();
+        await memory.initialize(cwd, env, config);
+        const generator = new TestGenerator({ config, env });
+        const result = await processGap(gap, options, generator, true, undefined, memory.toPromptSection());
+        return {
+            filesProcessed: 1,
+            testsWritten: result.success ? 1 : 0,
+            coverageBefore: 0,
+            coverageAfter: 0,
+            hasCoverage: false,
+            errors: result.error ? [result.error] : [],
+        };
+    }
+    // ─── Full suite path ──────────────────────────────────────────────────────────
+    const ageSeconds = await coverageAgeSeconds(config, cwd);
+    const useCached = !options.fresh && ageSeconds !== null && ageSeconds < COVERAGE_CACHE_TTL_S;
+    if (useCached) {
+        log(chalk.dim(`  Using cached coverage report (${Math.round(ageSeconds)}s old). Pass --fresh to re-run the suite.`));
+    }
+    else {
+        const spinner = startCoverageSpinner(chalk.dim('  Running test suite to collect coverage...'), env.testRunner);
+        const coverageResult = await runCommand(env.coverageCommand, cwd, config.coverageTimeout * 1000, spinner.onLine);
+        spinner.stop();
+        if (coverageResult.timedOut) {
+            throw new Error(`Test suite timed out after ${config.coverageTimeout}s.\n\n` +
+                `This usually means a test has an open handle (unclosed server, timer, or connection).\n` +
+                `Try running: ${env.testCommand} --reporter=verbose\n` +
+                `Or increase the timeout in .lacuna.json: { "coverageTimeout": ${config.coverageTimeout * 2} }`);
+        }
+        const zeroTests = /Tests:\s+0 total|no tests found/i.test(coverageResult.stdout + coverageResult.stderr);
+        if (zeroTests) {
+            throw new Error(`Your test suites are failing before any tests run.\n\n` +
+                `This usually means a missing environment variable, broken import, or setup file error.\n` +
+                `Run: ${env.testCommand} 2>&1 | head -80\nto see the actual error.`);
+        }
+    }
+    let report;
+    try {
+        report = await loadCoverage(config, cwd);
+    }
+    catch {
+        throw new Error(`Could not read coverage report from ./${config.coverageDir}/`);
+    }
+    const coverageBefore = report.totalLineRate * 100;
+    const gaps = await filterTestableGaps(extractGaps(report, config.threshold), config.ignore);
+    const untouchedFiles = await findUncoveredFiles(report, config.sourceDir, cwd, config.ignore);
+    const existingPaths = new Set(gaps.map((g) => g.filePath));
+    for (const g of untouchedFiles) {
+        if (!existingPaths.has(g.filePath))
+            gaps.push(g);
+    }
+    if (gaps.length === 0) {
+        log(chalk.green(`\nAll files already meet the ${config.threshold}% threshold.`));
+        return { filesProcessed: 0, testsWritten: 0, coverageBefore, coverageAfter: coverageBefore, hasCoverage: true, errors: [] };
+    }
+    log(chalk.bold(`\nFound ${gaps.length} file(s) below ${config.threshold}% threshold.`));
+    log(chalk.dim(`Coverage before: ${coverageBefore.toFixed(1)}%`));
+    if (parallel) {
+        if (options.verbose)
+            log(chalk.dim(`  (--verbose is not shown in parallel mode — use --workers 1 to see the live code panel)`));
+        log(chalk.dim(`\nWorkers: ${workerCount}\n`));
+    }
+    // Build project memory once — shared snapshot for all files in this run
+    const memory = new ProjectMemory();
+    await memory.initialize(cwd, env, config);
+    const memorySnapshot = memory.toPromptSection();
+    let filesProcessed;
+    let testsWritten;
+    let errors;
+    if (parallel) {
+        ;
+        ({ filesProcessed, testsWritten, errors } = await runWorkerPool(gaps, options, workerCount, memorySnapshot));
+        if (!options.dryRun) {
+            const finalSpinner = startCoverageSpinner(chalk.dim('\n  Running full suite for final coverage measurement...'), env.testRunner);
+            await runCommand(env.coverageCommand, cwd, config.coverageTimeout * 1000, finalSpinner.onLine);
+            finalSpinner.stop();
+        }
+    }
+    else {
+        filesProcessed = 0;
+        testsWritten = 0;
+        errors = [];
+        const generator = new TestGenerator({ config, env });
+        const tips = getActiveTips({
+            workers: 1,
+            targetFile: options.targetFile,
+            verbose: options.verbose,
+            dryRun: options.dryRun,
+            fresh: options.fresh,
+            model: config.model,
+            threshold: config.threshold,
+            mocksFile: config.mocksFile,
+            ignore: config.ignore,
+            command: 'generate',
+        });
+        const nextTip = createTipRotator(tips);
+        for (const gap of gaps) {
+            const tip = nextTip();
+            if (tip)
+                log(formatTip(tip));
+            const result = await processGap(gap, options, generator, false, undefined, memory.toPromptSection());
+            filesProcessed++;
+            if (result.success) {
+                testsWritten++;
+                // Update memory so subsequent files learn from patterns in this one
+                if (result.testCode) {
+                    memory.recordSuccess(gap.filePath.replace(cwd + '/', ''), result.testCode);
+                }
+            }
+            else if (result.error)
+                errors.push(result.error);
+        }
+    }
+    const coverageAfter = options.dryRun ? coverageBefore : await getCoverageRate(config, cwd);
+    return { filesProcessed, testsWritten, coverageBefore, coverageAfter, hasCoverage: true, errors };
+}
+//# sourceMappingURL=loop.js.map