@gordon.gan/specflow 1.8.0-beta → 1.8.2-beta

package/dist/core/approval/pipeline.js

@@ -1,146 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { join } from 'node:path';
-import { assembleApprovalDocument, readApprovalIndex } from './assemble.js';
-import { lintApprovalDocument } from './lint.js';
-import { bundleApprovalDocument, resolvePlaybookPath } from './bundle.js';
-import { checkApprovalReview, generateReviewPacket } from './review-pack.js';
-import { getApprovalReviewPath } from './paths.js';
-function mergeDiagnostics(target, next) {
-    target.push(...next);
-    return next.some((d) => d.severity === 'error');
-}
-async function reviewResultExists(changeDir) {
-    try {
-        await fs.access(getApprovalReviewPath(changeDir));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function shouldRunBundle(bundleOption, multiRepoBundleEnabled) {
-    if (bundleOption === true) {
-        return true;
-    }
-    if (bundleOption === false) {
-        return false;
-    }
-    return multiRepoBundleEnabled === true;
-}
-/**
- * One-shot ACP finalize: lint → review gate → check → assemble → optional bundle.
- * When AI review is required but review-result.json is missing, pauses after review-pack.
- */
-export async function finalizeApprovalDocument(options) {
-    const diagnostics = [];
-    const { changeDir, workspaceRoot = join(changeDir, '..', '..', '..'), strict = true, skipReview = false, force = true, bundle = 'auto', dryRun = false, validateLazy = true, } = options;
-    let index;
-    try {
-        index = await readApprovalIndex(changeDir);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            ok: false,
-            stage: 'lint',
-            change: '',
-            diagnostics: [
-                { code: 'missing_index', severity: 'error', message: `Cannot read index: ${message}` },
-            ],
-        };
-    }
-    const lintResult = await lintApprovalDocument({ changeDir, strict });
-    if (mergeDiagnostics(diagnostics, lintResult.diagnostics) || !lintResult.ok) {
-        return { ok: false, stage: 'lint', change: index.change, diagnostics };
-    }
-    const reviewEnabled = !skipReview &&
-        (index.acp?.review?.enabled === true || index.acp?.review?.required_pass === true);
-    let reviewPacketPath;
-    if (reviewEnabled) {
-        const hasReviewResult = await reviewResultExists(changeDir);
-        if (!hasReviewResult) {
-            const packResult = await generateReviewPacket({ changeDir });
-            reviewPacketPath = packResult.packetPath;
-            mergeDiagnostics(diagnostics, packResult.diagnostics);
-            if (!packResult.ok) {
-                return {
-                    ok: false,
-                    stage: 'review-pack',
-                    change: index.change,
-                    reviewPacketPath,
-                    diagnostics,
-                };
-            }
-            diagnostics.push({
-                code: 'review_required',
-                severity: 'error',
-                message: 'AI review required: read prompts/approval/ai-review.md, fix parts, write approval/review-result.json, then re-run specflow approval finalize',
-            });
-            return {
-                ok: false,
-                paused: true,
-                stage: 'review-required',
-                change: index.change,
-                reviewPacketPath,
-                diagnostics,
-            };
-        }
-        const reviewCheck = await checkApprovalReview({
-            changeDir,
-            requirePass: true,
-            forceRequire: index.acp?.review?.required_pass === true,
-        });
-        if (mergeDiagnostics(diagnostics, reviewCheck.diagnostics) || !reviewCheck.ok) {
-            return { ok: false, stage: 'review-check', change: index.change, diagnostics };
-        }
-    }
-    const checkResult = await assembleApprovalDocument({
-        changeDir,
-        checkOnly: true,
-        validateLazy,
-    });
-    if (mergeDiagnostics(diagnostics, checkResult.diagnostics) || !checkResult.ok) {
-        return { ok: false, stage: 'check', change: index.change, diagnostics };
-    }
-    if (dryRun) {
-        return { ok: true, stage: 'done', change: index.change, diagnostics };
-    }
-    const assembleResult = await assembleApprovalDocument({
-        changeDir,
-        checkOnly: false,
-        force,
-        validateLazy,
-    });
-    if (mergeDiagnostics(diagnostics, assembleResult.diagnostics) || !assembleResult.ok) {
-        return { ok: false, stage: 'assemble', change: index.change, diagnostics };
-    }
-    let bundlePath;
-    if (shouldRunBundle(bundle, index.multi_repo?.bundle?.enabled)) {
-        const playbookPath = await resolvePlaybookPath(changeDir, options.playbook);
-        const bundleResult = await bundleApprovalDocument({
-            workspaceRoot,
-            changeDir,
-            playbookPath,
-            write: true,
-        });
-        bundlePath = bundleResult.outputPath;
-        if (mergeDiagnostics(diagnostics, bundleResult.diagnostics) || !bundleResult.ok) {
-            return {
-                ok: false,
-                stage: 'bundle',
-                change: index.change,
-                outputPath: assembleResult.outputPath,
-                bundlePath,
-                diagnostics,
-            };
-        }
-    }
-    return {
-        ok: true,
-        stage: 'done',
-        change: index.change,
-        outputPath: assembleResult.outputPath,
-        bundlePath,
-        diagnostics,
-    };
-}

package/dist/core/approval/playbook-schema.d.ts

@@ -1,182 +0,0 @@
-import { z } from 'zod';
-import type { ApprovalPlaybook } from './types.js';
-export declare const approvalPlaybookSchema: z.ZodObject<{
-    schema: z.ZodLiteral<"specflow.approval.playbook/v1">;
-    change: z.ZodString;
-    title: z.ZodString;
-    primary_repo: z.ZodString;
-    sources: z.ZodArray<z.ZodObject<{
-        repo: z.ZodString;
-        change: z.ZodString;
-        include_parts: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"all">, z.ZodArray<z.ZodString, "many">]>>;
-        root: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        repo: string;
-        change: string;
-        root?: string | undefined;
-        include_parts?: string[] | "all" | undefined;
-    }, {
-        repo: string;
-        change: string;
-        root?: string | undefined;
-        include_parts?: string[] | "all" | undefined;
-    }>, "many">;
-    overlay: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    assemble: z.ZodObject<{
-        inject_headers: z.ZodOptional<z.ZodBoolean>;
-        dedupe_appendix: z.ZodOptional<z.ZodBoolean>;
-        output: z.ZodString;
-        readonly: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        output: string;
-        readonly?: boolean | undefined;
-        inject_headers?: boolean | undefined;
-        dedupe_appendix?: boolean | undefined;
-    }, {
-        output: string;
-        readonly?: boolean | undefined;
-        inject_headers?: boolean | undefined;
-        dedupe_appendix?: boolean | undefined;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    schema: "specflow.approval.playbook/v1";
-    change: string;
-    primary_repo: string;
-    title: string;
-    sources: {
-        repo: string;
-        change: string;
-        root?: string | undefined;
-        include_parts?: string[] | "all" | undefined;
-    }[];
-    assemble: {
-        output: string;
-        readonly?: boolean | undefined;
-        inject_headers?: boolean | undefined;
-        dedupe_appendix?: boolean | undefined;
-    };
-    overlay?: string[] | undefined;
-}, {
-    schema: "specflow.approval.playbook/v1";
-    change: string;
-    primary_repo: string;
-    title: string;
-    sources: {
-        repo: string;
-        change: string;
-        root?: string | undefined;
-        include_parts?: string[] | "all" | undefined;
-    }[];
-    assemble: {
-        output: string;
-        readonly?: boolean | undefined;
-        inject_headers?: boolean | undefined;
-        dedupe_appendix?: boolean | undefined;
-    };
-    overlay?: string[] | undefined;
-}>;
-export declare const approvalReviewResultSchema: z.ZodObject<{
-    schema: z.ZodLiteral<"specflow.approval.review/v1">;
-    change: z.ZodString;
-    reviewed_at: z.ZodString;
-    reviewer: z.ZodEnum<["ai", "human"]>;
-    findings: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        severity: z.ZodEnum<["critical", "important", "minor"]>;
-        category: z.ZodString;
-        message: z.ZodString;
-        part: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<["open", "fixed", "waived"]>;
-        waiver_reason: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        status: "fixed" | "open" | "waived";
-        message: string;
-        id: string;
-        severity: "critical" | "important" | "minor";
-        category: string;
-        part?: string | undefined;
-        waiver_reason?: string | undefined;
-    }, {
-        status: "fixed" | "open" | "waived";
-        message: string;
-        id: string;
-        severity: "critical" | "important" | "minor";
-        category: string;
-        part?: string | undefined;
-        waiver_reason?: string | undefined;
-    }>, "many">;
-    verdict: z.ZodEnum<["pass", "fail", "pass_with_waivers"]>;
-    summary: z.ZodOptional<z.ZodString>;
-    part_hashes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        sha256: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        sha256: string;
-    }, {
-        id: string;
-        sha256: string;
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    schema: "specflow.approval.review/v1";
-    change: string;
-    reviewed_at: string;
-    reviewer: "ai" | "human";
-    findings: {
-        status: "fixed" | "open" | "waived";
-        message: string;
-        id: string;
-        severity: "critical" | "important" | "minor";
-        category: string;
-        part?: string | undefined;
-        waiver_reason?: string | undefined;
-    }[];
-    verdict: "fail" | "pass" | "pass_with_waivers";
-    part_hashes?: {
-        id: string;
-        sha256: string;
-    }[] | undefined;
-    summary?: string | undefined;
-}, {
-    schema: "specflow.approval.review/v1";
-    change: string;
-    reviewed_at: string;
-    reviewer: "ai" | "human";
-    findings: {
-        status: "fixed" | "open" | "waived";
-        message: string;
-        id: string;
-        severity: "critical" | "important" | "minor";
-        category: string;
-        part?: string | undefined;
-        waiver_reason?: string | undefined;
-    }[];
-    verdict: "fail" | "pass" | "pass_with_waivers";
-    part_hashes?: {
-        id: string;
-        sha256: string;
-    }[] | undefined;
-    summary?: string | undefined;
-}>;
-export declare function parseApprovalPlaybook(raw: unknown): ApprovalPlaybook;
-export declare function parseApprovalReviewResult(raw: unknown): {
-    schema: "specflow.approval.review/v1";
-    change: string;
-    reviewed_at: string;
-    reviewer: "ai" | "human";
-    findings: {
-        status: "fixed" | "open" | "waived";
-        message: string;
-        id: string;
-        severity: "critical" | "important" | "minor";
-        category: string;
-        part?: string | undefined;
-        waiver_reason?: string | undefined;
-    }[];
-    verdict: "fail" | "pass" | "pass_with_waivers";
-    part_hashes?: {
-        id: string;
-        sha256: string;
-    }[] | undefined;
-    summary?: string | undefined;
-};

package/dist/core/approval/playbook-schema.js

@@ -1,51 +0,0 @@
-import { z } from 'zod';
-export const approvalPlaybookSchema = z.object({
-    schema: z.literal('specflow.approval.playbook/v1'),
-    change: z.string().min(1),
-    title: z.string().min(1),
-    primary_repo: z.string().min(1),
-    sources: z
-        .array(z.object({
-        repo: z.string().min(1),
-        change: z.string().min(1),
-        include_parts: z.union([z.literal('all'), z.array(z.string().min(1))]).optional(),
-        root: z.string().min(1).optional(),
-    }))
-        .min(1),
-    overlay: z.array(z.string().min(1)).optional(),
-    assemble: z.object({
-        inject_headers: z.boolean().optional(),
-        dedupe_appendix: z.boolean().optional(),
-        output: z.string().min(1),
-        readonly: z.boolean().optional(),
-    }),
-});
-export const approvalReviewResultSchema = z.object({
-    schema: z.literal('specflow.approval.review/v1'),
-    change: z.string().min(1),
-    reviewed_at: z.string().min(1),
-    reviewer: z.enum(['ai', 'human']),
-    findings: z.array(z.object({
-        id: z.string().min(1),
-        severity: z.enum(['critical', 'important', 'minor']),
-        category: z.string().min(1),
-        message: z.string().min(1),
-        part: z.string().optional(),
-        status: z.enum(['open', 'fixed', 'waived']),
-        waiver_reason: z.string().optional(),
-    })),
-    verdict: z.enum(['pass', 'fail', 'pass_with_waivers']),
-    summary: z.string().optional(),
-    part_hashes: z
-        .array(z.object({
-        id: z.string().min(1),
-        sha256: z.string().min(64).max(64),
-    }))
-        .optional(),
-});
-export function parseApprovalPlaybook(raw) {
-    return approvalPlaybookSchema.parse(raw);
-}
-export function parseApprovalReviewResult(raw) {
-    return approvalReviewResultSchema.parse(raw);
-}

package/dist/core/approval/render.d.ts

@@ -1,20 +0,0 @@
-import type { ApprovalDiagnostic } from './types.js';
-export interface RenderApprovalOptions {
-    readonly changeDir: string;
-    readonly inputPath?: string;
-    readonly outputPath?: string;
-    readonly title?: string;
-    readonly write?: boolean;
-}
-export interface RenderApprovalResult {
-    readonly ok: boolean;
-    readonly outputPath?: string;
-    readonly html?: string;
-    readonly sha256?: string;
-    readonly diagnostics: readonly ApprovalDiagnostic[];
-}
-export declare function renderApprovalDocument(options: RenderApprovalOptions): Promise<RenderApprovalResult>;
-export declare function resolveApprovalRenderPaths(changeDir: string, input?: string, output?: string): {
-    inputPath: string;
-    outputPath: string;
-};

package/dist/core/approval/render.js

@@ -1,210 +0,0 @@
-import { createHash } from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { marked } from 'marked';
-import { getApprovalOutputPath } from './paths.js';
-const APPROVAL_HTML_STYLES = `
-:root {
-  color-scheme: light dark;
-  --text: #1a1a1a;
-  --muted: #555;
-  --border: #ddd;
-  --code-bg: #f6f8fa;
-  --quote-bg: #f0f4ff;
-}
-@media (prefers-color-scheme: dark) {
-  :root {
-    --text: #e6edf3;
-    --muted: #9da7b3;
-    --border: #30363d;
-    --code-bg: #161b22;
-    --quote-bg: #1c2333;
-  }
-}
-* { box-sizing: border-box; }
-body {
-  margin: 0;
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "PingFang SC",
-    "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
-  line-height: 1.65;
-  color: var(--text);
-  background: #fff;
-}
-@media (prefers-color-scheme: dark) {
-  body { background: #0d1117; }
-}
-.page {
-  max-width: 920px;
-  margin: 0 auto;
-  padding: 2rem 1.5rem 4rem;
-}
-.meta {
-  font-size: 0.875rem;
-  color: var(--muted);
-  margin-bottom: 2rem;
-  padding-bottom: 1rem;
-  border-bottom: 1px solid var(--border);
-}
-article h1 { font-size: 1.75rem; margin-top: 0; }
-article h2 { font-size: 1.35rem; margin-top: 2rem; border-bottom: 1px solid var(--border); padding-bottom: 0.35rem; }
-article h3 { font-size: 1.15rem; margin-top: 1.5rem; }
-article h4, article h5 { font-size: 1rem; margin-top: 1.25rem; }
-article p, article li { margin: 0.5rem 0; }
-article blockquote {
-  margin: 1rem 0;
-  padding: 0.75rem 1rem;
-  border-left: 4px solid #0969da;
-  background: var(--quote-bg);
-  color: var(--muted);
-}
-article table {
-  width: 100%;
-  border-collapse: collapse;
-  margin: 1rem 0;
-  font-size: 0.92rem;
-}
-article th, article td {
-  border: 1px solid var(--border);
-  padding: 0.45rem 0.65rem;
-  text-align: left;
-}
-article th { background: var(--code-bg); }
-article code {
-  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-  font-size: 0.9em;
-  background: var(--code-bg);
-  padding: 0.15em 0.35em;
-  border-radius: 4px;
-}
-article pre {
-  overflow-x: auto;
-  padding: 1rem;
-  background: var(--code-bg);
-  border: 1px solid var(--border);
-  border-radius: 6px;
-}
-article pre code { background: none; padding: 0; }
-article hr { border: none; border-top: 1px solid var(--border); margin: 2rem 0; }
-.mermaid {
-  margin: 1rem 0;
-  text-align: center;
-}
-`.trim();
-function sha256(content) {
-    return createHash('sha256').update(content, 'utf8').digest('hex');
-}
-function defaultHtmlPath(markdownPath) {
-    if (markdownPath.endsWith('.md')) {
-        return markdownPath.slice(0, -3) + '.html';
-    }
-    return `${markdownPath}.html`;
-}
-function extractTitle(markdown, fallback) {
-    const match = markdown.match(/^#\s+(.+)$/m);
-    return match?.[1]?.trim() ?? fallback;
-}
-function configureMarked() {
-    marked.use({
-        gfm: true,
-        breaks: false,
-    });
-    marked.use({
-        renderer: {
-            code({ text, lang }) {
-                if (lang === 'mermaid') {
-                    return `<pre class="mermaid">${escapeHtml(text)}</pre>`;
-                }
-                const language = lang ? ` class="language-${lang}"` : '';
-                return `<pre><code${language}>${escapeHtml(text)}</code></pre>`;
-            },
-        },
-    });
-}
-function escapeHtml(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
-function buildHtmlDocument(title, bodyHtml, sourcePath) {
-    const hasMermaid = bodyHtml.includes('class="mermaid"');
-    const mermaidScript = hasMermaid
-        ? `<script type="module">
-import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
-mermaid.initialize({ startOnLoad: true, theme: 'neutral' });
-</script>`
-        : '';
-    return `<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>${escapeHtml(title)}</title>
-  <style>${APPROVAL_HTML_STYLES}</style>
-</head>
-<body>
-  <div class="page">
-    <div class="meta">SpecFlow approval render · source: ${escapeHtml(sourcePath)} · generated by <code>specflow approval render</code></div>
-    <article>${bodyHtml}</article>
-  </div>
-  ${mermaidScript}
-</body>
-</html>
-`;
-}
-export async function renderApprovalDocument(options) {
-    const diagnostics = [];
-    const { changeDir, write = true } = options;
-    const inputPath = options.inputPath ?? getApprovalOutputPath(changeDir);
-    const outputPath = options.outputPath ?? defaultHtmlPath(inputPath);
-    let markdown;
-    try {
-        markdown = await fs.readFile(inputPath, 'utf-8');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            ok: false,
-            diagnostics: [
-                {
-                    code: 'render_input_missing',
-                    severity: 'error',
-                    message: `Cannot read markdown: ${inputPath} (${message})`,
-                },
-            ],
-        };
-    }
-    if (markdown.trim().length < 20) {
-        diagnostics.push({
-            code: 'render_input_empty',
-            severity: 'error',
-            message: `Markdown input too short or empty: ${inputPath}`,
-        });
-        return { ok: false, diagnostics };
-    }
-    configureMarked();
-    const bodyHtml = await marked.parse(markdown);
-    const title = options.title ?? extractTitle(markdown, 'Approval Document');
-    const html = buildHtmlDocument(title, bodyHtml, inputPath);
-    const hash = sha256(html);
-    if (!write) {
-        return { ok: true, outputPath, html, sha256: hash, diagnostics };
-    }
-    await fs.mkdir(dirname(outputPath), { recursive: true });
-    await fs.writeFile(outputPath, html, 'utf-8');
-    return { ok: true, outputPath, html, sha256: hash, diagnostics };
-}
-export function resolveApprovalRenderPaths(changeDir, input, output) {
-    const inputPath = input
-        ? input.startsWith('/')
-            ? input
-            : join(changeDir, input)
-        : getApprovalOutputPath(changeDir);
-    const outputPath = output
-        ? output.startsWith('/')
-            ? output
-            : join(changeDir, output)
-        : defaultHtmlPath(inputPath);
-    return { inputPath, outputPath };
-}

package/dist/core/approval/review-pack.d.ts

@@ -1,26 +0,0 @@
-import type { ApprovalDiagnostic, ApprovalReviewPacket, ApprovalReviewResult } from './types.js';
-export declare function computeReviewPartHashes(changeDir: string, partIds: readonly string[]): Promise<{
-    id: string;
-    sha256: string;
-}[]>;
-export interface ReviewPackOptions {
-    readonly changeDir: string;
-}
-export interface ReviewPackResult {
-    readonly ok: boolean;
-    readonly packet?: ApprovalReviewPacket;
-    readonly packetPath?: string;
-    readonly diagnostics: readonly ApprovalDiagnostic[];
-}
-export declare function generateReviewPacket(options: ReviewPackOptions): Promise<ReviewPackResult>;
-export interface ReviewCheckOptions {
-    readonly changeDir: string;
-    readonly requirePass?: boolean;
-    readonly forceRequire?: boolean;
-}
-export interface ReviewCheckResult {
-    readonly ok: boolean;
-    readonly review?: ApprovalReviewResult;
-    readonly diagnostics: readonly ApprovalDiagnostic[];
-}
-export declare function checkApprovalReview(options: ReviewCheckOptions): Promise<ReviewCheckResult>;