edsger 0.42.1 → 0.44.0

package/dist/phases/release-sync/snapshot.js

@@ -0,0 +1,159 @@
+/**
+ * Snapshot detection: after the latest GitHub release already has a
+ * smoke-test plan, inspect the cloned repo for a yet-to-be-released
+ * "snapshot" version (next package.json version, an [Unreleased] entry
+ * in CHANGELOG, an unreleased git tag, etc.) so we can prepare the
+ * next smoke test before anyone cuts the tag on GitHub.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { findBalancedJsonObject } from '../../utils/json-extract.js';
+import { logDebug, logInfo } from '../../utils/logger.js';
+export function buildSnapshotDetectionPrompt(latestReleaseTag) {
+    return `You are inspecting a code repository to decide whether an unreleased "snapshot" version is being prepared.
+
+The most recent shipped release on GitHub is tagged: **${latestReleaseTag}**
+
+Your job:
+
+1. Read the repository's primary version source. In priority order:
+   - package.json "version" field (JS/TS projects)
+   - Cargo.toml [package] version (Rust)
+   - pyproject.toml [project] / [tool.poetry] version (Python)
+   - pom.xml <version> (Java / Maven)
+   - VERSION file (plain text)
+2. Read CHANGELOG.md / HISTORY.md / RELEASES.md for an [Unreleased] or similarly labelled section.
+3. Run \`git tag --list\` and \`git tag --sort=-creatordate | head -5\` to look for tags newer than ${latestReleaseTag} that have not yet been cut as GitHub releases.
+
+Then decide:
+- If the primary version source is strictly greater than ${latestReleaseTag} (accounting for "v" prefixes and semver prerelease suffixes like \`-SNAPSHOT\`, \`-rc.1\`, \`-next.0\`), OR there is a newer unreleased git tag, report that string as \`snapshot_tag\`.
+- Otherwise report \`snapshot_tag: null\`.
+- Do NOT invent a version. Use the exact string from the source file. Preserve the repo's existing tag convention (e.g. if releases are \`v1.2.3\` but package.json says \`1.2.3\`, return \`v1.2.3\`).
+
+Respond with ONLY a JSON object — no prose, no markdown fences:
+
+{
+  "snapshot_tag": "v2.0.0" | null,
+  "source": "package.json" | "Cargo.toml" | "pyproject.toml" | "pom.xml" | "VERSION" | "CHANGELOG" | "git_tag" | null,
+  "reasoning": "<one sentence>"
+}`;
+}
+export function parseSnapshotDetection(raw) {
+    let body = raw.trim();
+    const fence = body.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fence) {
+        body = fence[1].trim();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        const object = findBalancedJsonObject(body);
+        if (!object) {
+            throw new Error('No JSON object found in snapshot-detection output');
+        }
+        parsed = JSON.parse(object);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('Snapshot detection returned non-object response');
+    }
+    const obj = parsed;
+    const rawTag = obj.snapshot_tag;
+    const snapshotTag = typeof rawTag === 'string' && rawTag.trim().length > 0
+        ? rawTag.trim()
+        : null;
+    const source = typeof obj.source === 'string' ? obj.source : null;
+    const reasoning = typeof obj.reasoning === 'string' ? obj.reasoning : '(no reasoning given)';
+    return { snapshot_tag: snapshotTag, source, reasoning };
+}
+/**
+ * Very loose sanity check on a proposed snapshot tag. We reject tags
+ * that are obviously the same as the latest release or that contain
+ * characters that would break downstream git / GitHub API calls.
+ */
+export function isPlausibleSnapshotTag(candidate, latestReleaseTag) {
+    if (candidate === latestReleaseTag) {
+        return false;
+    }
+    if (candidate.length === 0 || candidate.length > 100) {
+        return false;
+    }
+    if (/\s/.test(candidate)) {
+        return false;
+    }
+    if (/^[-.]/.test(candidate) ||
+        candidate.includes('..') ||
+        candidate.includes('@{')) {
+        return false;
+    }
+    return /^[A-Za-z0-9._\-+/@]+$/.test(candidate);
+}
+function userMessage(content) {
+    return { type: 'user', message: { role: 'user', content } };
+}
+// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
+async function* makePrompt(text) {
+    yield userMessage(text);
+}
+// eslint-disable-next-line complexity -- agent loop with message-type handling
+export async function detectSnapshotVersion(options) {
+    const { cwd, latestReleaseTag, verbose } = options;
+    if (verbose) {
+        logInfo(`Detecting snapshot version ahead of ${latestReleaseTag}...`);
+    }
+    let lastAssistant = '';
+    let detection = null;
+    for await (const message of query({
+        prompt: makePrompt(buildSnapshotDetectionPrompt(latestReleaseTag)),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 10,
+            permissionMode: 'bypassPermissions',
+            cwd,
+        },
+    })) {
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistant += `${content.text}\n`;
+                    logDebug(content.text, verbose);
+                }
+            }
+        }
+        if (message.type === 'result') {
+            const text = ('result' in message ? message.result : '') || lastAssistant;
+            try {
+                detection = parseSnapshotDetection(text);
+            }
+            catch (err) {
+                if (verbose) {
+                    logDebug(`Snapshot detection parse error: ${err instanceof Error ? err.message : String(err)}`, verbose);
+                }
+            }
+        }
+    }
+    if (!detection) {
+        return {
+            snapshot_tag: null,
+            source: null,
+            reasoning: 'Could not parse detection response',
+        };
+    }
+    // Validate the proposed tag before returning.
+    if (detection.snapshot_tag !== null &&
+        !isPlausibleSnapshotTag(detection.snapshot_tag, latestReleaseTag)) {
+        if (verbose) {
+            logInfo(`Rejecting implausible snapshot tag: ${JSON.stringify(detection.snapshot_tag)}`);
+        }
+        return {
+            ...detection,
+            snapshot_tag: null,
+        };
+    }
+    return detection;
+}

package/dist/phases/smoke-test/__tests__/agent.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for smoke-test agent response parsing.
+ */
+export {};

package/dist/phases/smoke-test/__tests__/agent.test.js

@@ -0,0 +1,85 @@
+/**
+ * Unit tests for smoke-test agent response parsing.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { findBalancedJsonObject } from '../../../utils/json-extract.js';
+import { extractJson } from '../agent.js';
+void describe('extractJson', () => {
+    void it('parses a plain JSON object', () => {
+        const raw = `{
+      "summary": "one thing changed",
+      "test_cases": [
+        { "name": "login still works", "description": "step 1", "is_critical": true }
+      ]
+    }`;
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'one thing changed');
+        assert.strictEqual(parsed.test_cases.length, 1);
+        assert.strictEqual(parsed.test_cases[0].is_critical, true);
+    });
+    void it('strips ```json fences', () => {
+        const raw = '```json\n{"summary":"x","test_cases":[{"name":"a","description":"b"}]}\n```';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+        assert.strictEqual(parsed.test_cases[0].name, 'a');
+    });
+    void it('strips unlabeled fences', () => {
+        const raw = '```\n{"summary":"x","test_cases":[]}\n```';
+        const parsed = extractJson(raw);
+        assert.deepStrictEqual(parsed.test_cases, []);
+    });
+    void it('tolerates leading and trailing prose', () => {
+        const raw = `Here you go:
+{"summary":"x","test_cases":[{"name":"a","description":"b"}]}
+
+Hope that helps.`;
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+    });
+    void it('throws when test_cases is missing', () => {
+        assert.throws(() => extractJson('{"summary":"x"}'), /test_cases/);
+    });
+    void it('throws on invalid JSON', () => {
+        assert.throws(() => extractJson('not json'));
+    });
+    void it('picks the first balanced object when prose contains decoy braces', () => {
+        const raw = 'Note: { pseudo-json example } but the real answer is:\n' +
+            '{"summary":"x","test_cases":[{"name":"a","description":"b"}]}\n' +
+            'Let me know if you want changes.';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+        assert.strictEqual(parsed.test_cases[0].name, 'a');
+    });
+    void it('preserves braces inside JSON string values', () => {
+        const raw = '{"summary":"changes to {pricing} and {checkout}","test_cases":[{"name":"n","description":"d"}]}';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'changes to {pricing} and {checkout}');
+    });
+    void it('throws when test_cases is not an array', () => {
+        assert.throws(() => extractJson('{"summary":"x","test_cases":"nope"}'), /test_cases/);
+    });
+});
+void describe('findBalancedJsonObject', () => {
+    void it('returns null when there is no opening brace', () => {
+        assert.strictEqual(findBalancedJsonObject('no braces here'), null);
+    });
+    void it('returns the first balanced top-level object', () => {
+        assert.strictEqual(findBalancedJsonObject('prefix {"a": 1} and {"b": 2} suffix'), '{"a": 1}');
+    });
+    void it('handles nested braces', () => {
+        const text = 'xxx {"a": {"b": {"c": 1}}} yyy';
+        assert.strictEqual(findBalancedJsonObject(text), '{"a": {"b": {"c": 1}}}');
+    });
+    void it('ignores braces inside strings', () => {
+        const text = '{"msg": "this has { and } inside", "ok": true}';
+        assert.strictEqual(findBalancedJsonObject(text), text);
+    });
+    void it('handles escaped quotes inside strings', () => {
+        const text = '{"msg": "she said \\"hi\\" {not object}"}';
+        assert.strictEqual(findBalancedJsonObject(text), text);
+    });
+    void it('returns null on unbalanced input', () => {
+        assert.strictEqual(findBalancedJsonObject('{"a": 1'), null);
+    });
+});

package/dist/phases/smoke-test/agent.d.ts

@@ -0,0 +1,12 @@
+import { type EdsgerConfig } from '../../types/index.js';
+export interface GeneratedSmokeTestPlan {
+    summary: string;
+    test_cases: {
+        name: string;
+        description: string;
+        is_critical?: boolean;
+    }[];
+}
+/** @internal Exported for unit tests only. */
+export declare function extractJson(raw: string): GeneratedSmokeTestPlan;
+export declare function executeSmokeTestQuery(systemPrompt: string, userPrompt: string, config: EdsgerConfig, verbose?: boolean, cwd?: string): Promise<GeneratedSmokeTestPlan>;

package/dist/phases/smoke-test/agent.js

@@ -0,0 +1,94 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { findBalancedJsonObject } from '../../utils/json-extract.js';
+import { logDebug, logError, logInfo } from '../../utils/logger.js';
+function userMessage(content) {
+    return { type: 'user', message: { role: 'user', content } };
+}
+// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
+async function* makePrompt(text) {
+    yield userMessage(text);
+}
+/** @internal Exported for unit tests only. */
+export function extractJson(raw) {
+    let body = raw.trim();
+    const fence = body.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fence) {
+        body = fence[1].trim();
+    }
+    // Try parsing the whole body first — if the model returned clean JSON
+    // it round-trips without needing to slice.
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        const object = findBalancedJsonObject(body);
+        if (!object) {
+            throw new Error('No JSON object found in model output');
+        }
+        parsed = JSON.parse(object);
+    }
+    if (typeof parsed !== 'object' ||
+        parsed === null ||
+        !Array.isArray(parsed.test_cases)) {
+        throw new Error('Model response is missing test_cases array');
+    }
+    return parsed;
+}
+// eslint-disable-next-line complexity -- agent loop with message type handling
+export async function executeSmokeTestQuery(systemPrompt, userPrompt, config, verbose, cwd) {
+    let lastAssistant = '';
+    let plan = null;
+    let parseError = null;
+    let turnCount = 0;
+    if (verbose) {
+        logInfo('Connecting to Claude Code for smoke-test generation...');
+    }
+    for await (const message of query({
+        prompt: makePrompt(userPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 20,
+            permissionMode: 'bypassPermissions',
+            ...(cwd ? { cwd } : {}),
+        },
+    })) {
+        if (message.type === 'assistant' && message.message?.content) {
+            turnCount++;
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistant += `${content.text}\n`;
+                    logDebug(content.text, verbose);
+                }
+                else if (content.type === 'tool_use') {
+                    const desc = content.input?.description || content.input?.command || 'Running...';
+                    if (verbose) {
+                        logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
+                    }
+                }
+            }
+        }
+        if (message.type === 'result') {
+            const text = ('result' in message ? message.result : '') || lastAssistant;
+            try {
+                plan = extractJson(text);
+            }
+            catch (err) {
+                parseError = err instanceof Error ? err.message : String(err);
+            }
+            if (message.subtype !== 'success') {
+                logError(`Smoke-test query incomplete: ${message.subtype}`);
+            }
+        }
+    }
+    if (!plan) {
+        throw new Error(`Failed to parse smoke-test plan from model output: ${parseError ?? 'no result message received'}`);
+    }
+    return plan;
+}

package/dist/phases/smoke-test/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Smoke-test generation for a single release row. Given a release that has
+ * already been synced into the `releases` table (see `phases/release-sync`),
+ * this phase clones the repo, diffs against the baseline, and asks Claude
+ * to emit a JSON test plan, then persists the test cases and marks the
+ * release `ready`.
+ */
+import { type EdsgerConfig } from '../../types/index.js';
+export interface SmokeTestOptions {
+    releaseId: string;
+    verbose?: boolean;
+}
+export interface SmokeTestResult {
+    status: 'success' | 'error';
+    releaseId: string;
+    releaseTag?: string;
+    previousReleaseTag?: string | null;
+    casesCount?: number;
+    summary: string;
+    isSnapshot?: boolean;
+}
+export declare function runSmokeTest(options: SmokeTestOptions, config: EdsgerConfig): Promise<SmokeTestResult>;

package/dist/phases/smoke-test/index.js

@@ -0,0 +1,233 @@
+/**
+ * Smoke-test generation for a single release row. Given a release that has
+ * already been synced into the `releases` table (see `phases/release-sync`),
+ * this phase clones the repo, diffs against the baseline, and asks Claude
+ * to emit a JSON test plan, then persists the test cases and marks the
+ * release `ready`.
+ */
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getProduct } from '../../api/products.js';
+import { clearReleaseTestCases, createReleaseTestCases, } from '../../api/release-test-cases.js';
+import { getRelease, updateRelease } from '../../api/releases.js';
+import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
+import { cloneFeatureRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { buildDiffDigest, fetchCompare, getDefaultBranchHead, summariseStats, } from '../release-sync/github.js';
+import { executeSmokeTestQuery } from './agent.js';
+import { buildSmokeTestUserPrompt, createSmokeTestSystemPrompt, } from './prompts.js';
+function isSnapshotRelease(release) {
+    return !release.published_at && !release.url;
+}
+// eslint-disable-next-line complexity -- orchestration spans GitHub + DB + AI
+export async function runSmokeTest(options, config) {
+    const { releaseId, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting smoke-test generation for release: ${releaseId}`);
+    }
+    let release;
+    try {
+        release = await getRelease(releaseId, verbose);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            status: 'error',
+            releaseId,
+            summary: `Failed to load release: ${message}`,
+        };
+    }
+    const gh = await getGitHubConfigByProduct(release.product_id, verbose);
+    if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
+        return {
+            status: 'error',
+            releaseId,
+            summary: gh.message ||
+                'Product is not connected to a GitHub repository. Connect it in Product Settings.',
+        };
+    }
+    const ghResolved = { owner: gh.owner, repo: gh.repo, token: gh.token };
+    const isSnapshot = isSnapshotRelease(release);
+    // Mark release as generating up front so the UI reflects progress.
+    let markedGenerating = false;
+    try {
+        await updateRelease({ release_id: release.id, status: 'generating', generation_error: null }, verbose);
+        markedGenerating = true;
+    }
+    catch (err) {
+        logWarning(`Could not mark release as generating: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        return await runSmokeTestInner({
+            release,
+            gh: ghResolved,
+            isSnapshot,
+            config,
+            verbose,
+        });
+    }
+    catch (err) {
+        // Safety net: an uncaught throw past the `generating` mark would leave the
+        // release row stuck. Flip it to `failed` so the UI isn't permanently stale.
+        const message = err instanceof Error ? err.message : String(err);
+        if (markedGenerating) {
+            try {
+                await updateRelease({
+                    release_id: release.id,
+                    status: 'failed',
+                    generation_error: `Unexpected error: ${message}`,
+                }, verbose);
+            }
+            catch {
+                // best effort
+            }
+        }
+        logError(`Smoke-test generation failed: ${message}`);
+        return {
+            status: 'error',
+            releaseId: release.id,
+            releaseTag: release.tag,
+            summary: message,
+        };
+    }
+}
+// eslint-disable-next-line complexity -- orchestration spans GitHub + DB + AI
+async function runSmokeTestInner(ctx) {
+    const { release, gh: ghResolved, isSnapshot, config, verbose } = ctx;
+    // Clone + checkout the ref Claude should read.
+    let cwd;
+    try {
+        const workspaceRoot = ensureWorkspaceDir();
+        const { repoPath } = cloneFeatureRepo(workspaceRoot, `release-${release.product_id}`, ghResolved.owner, ghResolved.repo, ghResolved.token);
+        cwd = repoPath;
+    }
+    catch (err) {
+        logWarning(`Could not clone repo (continuing without code access): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Decide the diff head. For shipped releases this is the release tag; for
+    // snapshots it's the default branch HEAD SHA.
+    let diffHead = release.tag;
+    if (cwd && isSnapshot) {
+        try {
+            const head = await getDefaultBranchHead(ghResolved.owner, ghResolved.repo, ghResolved.token);
+            syncRepoToRef(cwd, { branch: head.branch }, ghResolved.token);
+            diffHead = head.sha;
+        }
+        catch (err) {
+            logWarning(`Could not sync to default branch head: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else if (cwd && !isSnapshot) {
+        try {
+            syncRepoToRef(cwd, { tag: release.tag }, ghResolved.token);
+        }
+        catch (err) {
+            logWarning(`Could not checkout release tag ${release.tag}, continuing on default ref: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // Reset non-approved cases so the run is idempotent.
+    try {
+        await clearReleaseTestCases(release.id, verbose);
+    }
+    catch (err) {
+        logWarning(`Could not clear existing draft cases: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Fetch diff (skip if there is no baseline).
+    let diffDigest = '(No baseline to diff against — generate smoke tests covering the entire release notes.)';
+    let diffStats = {
+        files_changed: 0,
+        additions: 0,
+        deletions: 0,
+        total_commits: 0,
+    };
+    if (release.previous_tag) {
+        try {
+            const compare = await fetchCompare(ghResolved.owner, ghResolved.repo, release.previous_tag, diffHead, ghResolved.token);
+            diffDigest = buildDiffDigest(compare);
+            diffStats = summariseStats(compare);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            await updateRelease({
+                release_id: release.id,
+                status: 'failed',
+                generation_error: `Failed to fetch diff: ${message}`,
+            }, verbose);
+            return {
+                status: 'error',
+                releaseId: release.id,
+                releaseTag: release.tag,
+                summary: `Failed to fetch diff: ${message}`,
+            };
+        }
+    }
+    // Pull product metadata for the prompt.
+    const product = await getProduct(release.product_id, verbose).catch(() => null);
+    const productName = product?.name ?? 'Unknown product';
+    const productDescription = product?.description ?? null;
+    // Run Claude to produce the test plan.
+    let plan;
+    try {
+        const systemPrompt = await createSmokeTestSystemPrompt(Boolean(cwd), cwd);
+        plan = await executeSmokeTestQuery(systemPrompt, buildSmokeTestUserPrompt({
+            productName,
+            productDescription,
+            latestTag: release.tag,
+            previousTag: release.previous_tag,
+            releaseNotes: release.body ?? null,
+            diffDigest,
+        }), config, verbose, cwd);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        await updateRelease({ release_id: release.id, status: 'failed', generation_error: message }, verbose);
+        logError(`Smoke-test generation failed: ${message}`);
+        return {
+            status: 'error',
+            releaseId: release.id,
+            releaseTag: release.tag,
+            summary: message,
+        };
+    }
+    let casesCount = 0;
+    try {
+        casesCount = await createReleaseTestCases(release.id, plan.test_cases.map((c) => ({
+            name: c.name,
+            description: c.description,
+            is_critical: c.is_critical ?? false,
+        })), verbose);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        await updateRelease({
+            release_id: release.id,
+            status: 'failed',
+            generation_error: `Failed to insert cases: ${message}`,
+        }, verbose);
+        return {
+            status: 'error',
+            releaseId: release.id,
+            releaseTag: release.tag,
+            summary: `Failed to insert cases: ${message}`,
+        };
+    }
+    await updateRelease({
+        release_id: release.id,
+        status: 'ready',
+        diff_summary: plan.summary,
+        diff_stats: diffStats,
+        generation_error: null,
+    }, verbose);
+    logSuccess(`Generated ${casesCount} smoke-test cases for ${release.tag}${isSnapshot
+        ? ` (snapshot ahead of ${release.previous_tag ?? 'first release'})`
+        : release.previous_tag
+            ? ` (vs ${release.previous_tag})`
+            : ' (first release)'}`);
+    return {
+        status: 'success',
+        releaseId: release.id,
+        releaseTag: release.tag,
+        previousReleaseTag: release.previous_tag,
+        casesCount,
+        summary: plan.summary,
+        isSnapshot,
+    };
+}

package/dist/phases/smoke-test/prompts.d.ts

@@ -0,0 +1,15 @@
+export interface SmokeTestPromptInput {
+    productName: string;
+    productDescription: string | null;
+    latestTag: string;
+    previousTag: string | null;
+    releaseNotes: string | null;
+    diffDigest: string;
+}
+/**
+ * Load the smoke-test system prompt from the shared SKILL.md library.
+ * Keeping the prompt in a skill file means it can also be consumed by
+ * Claude Code, other agents, or edited by users in the desktop app.
+ */
+export declare function createSmokeTestSystemPrompt(hasCodebase?: boolean, projectDir?: string): Promise<string>;
+export declare function buildSmokeTestUserPrompt(input: SmokeTestPromptInput): string;

package/dist/phases/smoke-test/prompts.js

@@ -0,0 +1,35 @@
+import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
+/**
+ * Load the smoke-test system prompt from the shared SKILL.md library.
+ * Keeping the prompt in a skill file means it can also be consumed by
+ * Claude Code, other agents, or edited by users in the desktop app.
+ */
+export async function createSmokeTestSystemPrompt(hasCodebase = false, projectDir) {
+    const skill = await resolveSkill('phase/smoke-test', { projectDir });
+    if (!skill) {
+        throw new Error('Failed to load skill: phase/smoke-test');
+    }
+    return processConditionals(skill.prompt, { hasCodebase });
+}
+export function buildSmokeTestUserPrompt(input) {
+    const productBlock = input.productDescription
+        ? `Product: ${input.productName}\nDescription: ${input.productDescription}`
+        : `Product: ${input.productName}`;
+    const baseBlock = input.previousTag
+        ? `Previous release: ${input.previousTag}`
+        : 'Previous release: (none — this is the first release)';
+    const notesBlock = input.releaseNotes
+        ? `Release notes for ${input.latestTag}:\n${input.releaseNotes.slice(0, 4000)}`
+        : `Release notes for ${input.latestTag}: (none)`;
+    return `${productBlock}
+
+Release to ship: ${input.latestTag}
+${baseBlock}
+
+${notesBlock}
+
+Code changes between the two releases:
+${input.diffDigest}
+
+Produce the smoke-test plan as described in the system prompt.`;
+}

package/dist/phases/technical-design/index.js

@@ -24,7 +24,9 @@ async function* prompt(analysisPrompt) {
         setTimeout(res, 10000);
     });
 }
-export const generateTechnicalDesign = async (options, config, checklistContext) => {
+export const generateTechnicalDesign = async (options, config, checklistContext
+// eslint-disable-next-line complexity
+) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting technical design generation for feature ID: ${featureId}`);