peaks-loop 3.0.0

package/dist/src/services/openspec/openspec-propose-from-doctor-service.js

@@ -0,0 +1,95 @@
+/**
+ * openspec-propose-from-doctor-service (Slice L3.3) — generates a draft
+ * OpenSpec change record (proposal.md) from a doctor CRITICAL finding.
+ *
+ * Per L1+L2+L3 redesign §5.4: "CRITICAL → proposal 草稿生成". The doctor
+ * scans the project for issues; when a CRITICAL finding is surfaced,
+ * peaks-cli generates a draft `openspec/changes/<id>/proposal.md` so the
+ * LLM doesn't have to start from scratch.
+ *
+ * The draft proposal is INFORMATIONAL — it requires the LLM to review +
+ * edit before `peaks openspec validate` will accept it.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getErrorMessage } from '../../shared/result.js';
+const SLUGIFY = /[^a-z0-9]+/g;
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(SLUGIFY, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 50);
+}
+function formatProposal(input) {
+    return `# Doctor Finding: ${input.finding.rule}
+
+**Date**: ${input.date}
+**Change ID**: ${input.changeId}
+**Source**: \`peaks doctor\` finding (CRITICAL severity: ${input.finding.severity})
+
+## Why
+
+A \`peaks doctor\` scan flagged the following issue at \`${input.finding.id}\`:
+
+> ${input.finding.detail}
+
+The current behavior is broken or degraded. This proposal outlines a fix.
+
+## What Changes
+
+- Address the doctor finding at \`${input.finding.id}\`.
+- See the Why section above for the original error message.
+- Acceptance criteria below describe the success conditions.
+
+## Acceptance Criteria
+
+- \`peaks doctor --json\` returns \`ok: true\` for the \`${input.finding.id}\` check.
+- Re-running the audit does not regress other findings.
+
+## Out of Scope
+
+- Other doctor findings (each is tracked in its own OpenSpec change).
+- Refactors that don't fix this specific issue.
+
+## Risks
+
+- Low: this is a doctor-flagged issue with a clear acceptance criterion.
+
+## Status
+
+- created: ${input.date}
+- last update: ${input.date}
+- state: draft
+- state reason: auto-generated from peaks doctor; LLM must review + edit before validate
+`;
+}
+function makeChangeId(finding, date) {
+    return `${date}-fix-${slugify(finding.id)}`;
+}
+export function proposeFromDoctor(input) {
+    const date = (input.clock ?? (() => new Date().toISOString()))().slice(0, 10);
+    const changeId = makeChangeId(input.finding, date);
+    const changeDir = join(input.projectRoot, 'openspec/changes', changeId);
+    const proposalPath = join(changeDir, 'proposal.md');
+    let created = false;
+    try {
+        if (!existsSync(changeDir)) {
+            mkdirSync(changeDir, { recursive: true });
+        }
+        if (!existsSync(proposalPath)) {
+            const content = formatProposal({
+                changeId,
+                finding: input.finding,
+                title: `Fix ${input.finding.rule}`,
+                date,
+            });
+            writeFileSync(proposalPath, content);
+            created = true;
+        }
+    }
+    catch (error) {
+        throw new Error(`proposeFromDoctor: ${getErrorMessage(error)}`);
+    }
+    return { changeId, changeDir, proposalPath, created };
+}

package/dist/src/services/openspec/openspec-render-service.d.ts

@@ -0,0 +1,38 @@
+import { type JsonSchemaIssue } from '../../shared/json-schema-mini.js';
+export type OpenSpecRenderTaskSection = {
+    heading: string;
+    todos: string[];
+    doneItems?: string[];
+};
+export type OpenSpecRenderRequest = {
+    changeId: string;
+    why: string;
+    whatChanges: string[];
+    acceptanceCriteria: string[];
+    outOfScope?: string[];
+    dependencies?: string[];
+    risks?: string[];
+    tasks?: OpenSpecRenderTaskSection[];
+    design?: string;
+};
+export type OpenSpecRenderedFile = {
+    path: string;
+    content: string;
+};
+export type OpenSpecRenderResult = {
+    changeId: string;
+    changeRoot: string;
+    files: OpenSpecRenderedFile[];
+    applied: boolean;
+};
+export type OpenSpecRenderOptions = {
+    openspecRoot?: string;
+    apply?: boolean;
+    overwrite?: boolean;
+    schemaPath?: string;
+};
+export declare class OpenSpecRenderRequestInvalidError extends Error {
+    readonly issues: JsonSchemaIssue[];
+    constructor(issues: JsonSchemaIssue[]);
+}
+export declare function renderOpenSpecChange(request: OpenSpecRenderRequest, options?: OpenSpecRenderOptions): Promise<OpenSpecRenderResult>;

package/dist/src/services/openspec/openspec-render-service.js

@@ -0,0 +1,130 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isDirectory, pathExists } from '../../shared/fs.js';
+import { validateAgainstSchema } from '../../shared/json-schema-mini.js';
+const CHANGE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function defaultOpenSpecRoot() {
+    return join(process.cwd(), 'openspec');
+}
+function defaultSchemaPath() {
+    const here = fileURLToPath(import.meta.url);
+    return resolve(here, '..', '..', '..', '..', 'schemas', 'openspec-render-request.schema.json');
+}
+let cachedSchema = null;
+let cachedSchemaPath = null;
+async function loadSchema(schemaPath) {
+    if (cachedSchema !== null && cachedSchemaPath === schemaPath) {
+        return cachedSchema;
+    }
+    if (!(await pathExists(schemaPath))) {
+        return null;
+    }
+    const raw = await readFile(schemaPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    cachedSchema = parsed;
+    cachedSchemaPath = schemaPath;
+    return parsed;
+}
+function formatSchemaIssue(issue) {
+    return `${issue.path}: ${issue.message}`;
+}
+export class OpenSpecRenderRequestInvalidError extends Error {
+    issues;
+    constructor(issues) {
+        const summary = issues.map(formatSchemaIssue).join('; ');
+        super(`OpenSpec render request failed schema validation: ${summary}`);
+        this.name = 'OpenSpecRenderRequestInvalidError';
+        this.issues = issues;
+    }
+}
+function renderBullets(items) {
+    if (items === undefined || items.length === 0) {
+        return '_None_\n';
+    }
+    return `${items.map((item) => `- ${item}`).join('\n')}\n`;
+}
+function renderProposal(request) {
+    const lines = [];
+    lines.push(`# Change: ${request.changeId}`);
+    lines.push('');
+    lines.push('## Why');
+    lines.push('');
+    lines.push(request.why.length > 0 ? request.why : '_None_');
+    lines.push('');
+    lines.push('## What Changes');
+    lines.push('');
+    lines.push(renderBullets(request.whatChanges));
+    lines.push('## Out of Scope');
+    lines.push('');
+    lines.push(renderBullets(request.outOfScope));
+    lines.push('## Dependencies');
+    lines.push('');
+    lines.push(renderBullets(request.dependencies));
+    lines.push('## Risks');
+    lines.push('');
+    lines.push(renderBullets(request.risks));
+    lines.push('## Acceptance Criteria');
+    lines.push('');
+    lines.push(renderBullets(request.acceptanceCriteria));
+    return lines.join('\n');
+}
+function renderTasks(tasks) {
+    const sections = ['# Tasks', ''];
+    for (const task of tasks) {
+        sections.push(`## ${task.heading}`);
+        sections.push('');
+        for (const todo of task.todos) {
+            sections.push(`- [ ] ${todo}`);
+        }
+        if (task.doneItems !== undefined) {
+            for (const done of task.doneItems) {
+                sections.push(`- [x] ${done}`);
+            }
+        }
+        sections.push('');
+    }
+    return sections.join('\n');
+}
+function buildFiles(request, changeRoot) {
+    const files = [
+        { path: join(changeRoot, 'proposal.md'), content: renderProposal(request) }
+    ];
+    if (request.tasks !== undefined && request.tasks.length > 0) {
+        files.push({ path: join(changeRoot, 'tasks.md'), content: renderTasks(request.tasks) });
+    }
+    if (request.design !== undefined) {
+        files.push({ path: join(changeRoot, 'design.md'), content: request.design });
+    }
+    return files;
+}
+async function writeRenderedFiles(files) {
+    for (const file of files) {
+        await mkdir(dirname(file.path), { recursive: true });
+        await writeFile(file.path, file.content, 'utf8');
+    }
+}
+export async function renderOpenSpecChange(request, options = {}) {
+    const schemaPath = options.schemaPath ?? defaultSchemaPath();
+    const schema = await loadSchema(schemaPath);
+    if (schema !== null) {
+        const result = validateAgainstSchema(request, schema);
+        if (!result.valid) {
+            throw new OpenSpecRenderRequestInvalidError(result.errors);
+        }
+    }
+    else if (!CHANGE_ID_PATTERN.test(request.changeId)) {
+        throw new Error(`Invalid changeId: ${request.changeId} (expected letters, digits, dots, underscores, or dashes)`);
+    }
+    const openspecRoot = options.openspecRoot ?? defaultOpenSpecRoot();
+    const changeRoot = join(openspecRoot, 'changes', request.changeId);
+    const files = buildFiles(request, changeRoot);
+    if (options.apply !== true) {
+        return { changeId: request.changeId, changeRoot, files, applied: false };
+    }
+    if (options.overwrite !== true && (await isDirectory(changeRoot))) {
+        throw new Error(`Refusing to render: change directory already exists at ${changeRoot}. Re-run with overwrite to replace it.`);
+    }
+    await writeRenderedFiles(files);
+    return { changeId: request.changeId, changeRoot, files, applied: true };
+}

package/dist/src/services/openspec/openspec-scan-service.d.ts

@@ -0,0 +1,6 @@
+import type { OpenSpecChangeDetail, OpenSpecScanReport } from './openspec-types.js';
+export type OpenSpecScanOptions = {
+    openspecRoot?: string;
+};
+export declare function scanOpenSpec(options?: OpenSpecScanOptions): Promise<OpenSpecScanReport>;
+export declare function loadOpenSpecChange(changeId: string, options?: OpenSpecScanOptions): Promise<OpenSpecChangeDetail | null>;

package/dist/src/services/openspec/openspec-scan-service.js

@@ -0,0 +1,123 @@
+import { join } from 'node:path';
+import { isDirectory, listDirectories, pathExists, readText } from '../../shared/fs.js';
+function defaultOpenSpecRoot() {
+    return join(process.cwd(), 'openspec');
+}
+function parseMarkdownSections(markdown) {
+    const sections = new Map();
+    const lines = markdown.split(/\r?\n/);
+    let currentHeading = null;
+    let buffer = [];
+    const flush = () => {
+        if (currentHeading !== null) {
+            sections.set(currentHeading, buffer.join('\n').trim());
+        }
+    };
+    for (const line of lines) {
+        if (line.startsWith('## ')) {
+            flush();
+            currentHeading = line.slice(3).trim();
+            buffer = [];
+        }
+        else if (currentHeading !== null) {
+            buffer.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+function parseBullets(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('- ') || line === '-')
+        .map((line) => line.replace(/^-\s*/, '').trim())
+        .filter((line) => line.length > 0 && !line.startsWith('[ ]') && !line.startsWith('[x]') && !line.startsWith('[X]'));
+}
+function parseProposal(markdown) {
+    const sections = parseMarkdownSections(markdown);
+    const why = sections.get('Why') ?? '';
+    return {
+        why,
+        whatChanges: parseBullets(sections.get('What Changes') ?? ''),
+        outOfScope: parseBullets(sections.get('Out of Scope') ?? ''),
+        dependencies: parseBullets(sections.get('Dependencies') ?? ''),
+        risks: parseBullets(sections.get('Risks') ?? ''),
+        acceptanceCriteria: parseBullets(sections.get('Acceptance Criteria') ?? '')
+    };
+}
+function parseTaskProgress(markdown) {
+    const sections = parseMarkdownSections(markdown);
+    const sectionEntries = [];
+    let totalTodo = 0;
+    let doneTodo = 0;
+    for (const [heading, body] of sections.entries()) {
+        let sectionTotal = 0;
+        let sectionDone = 0;
+        for (const line of body.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (/^- \[[ xX]\]/.test(trimmed)) {
+                sectionTotal += 1;
+                if (/^- \[[xX]\]/.test(trimmed)) {
+                    sectionDone += 1;
+                }
+            }
+        }
+        if (sectionTotal > 0) {
+            sectionEntries.push({ heading, total: sectionTotal, done: sectionDone });
+            totalTodo += sectionTotal;
+            doneTodo += sectionDone;
+        }
+    }
+    return { totalTodo, doneTodo, sections: sectionEntries };
+}
+async function listSpecs(changeRoot) {
+    const specsRoot = join(changeRoot, 'specs');
+    if (!(await isDirectory(specsRoot))) {
+        return [];
+    }
+    return listDirectories(specsRoot);
+}
+async function resolvePaths(changeRoot) {
+    const proposalPath = join(changeRoot, 'proposal.md');
+    const tasksPath = join(changeRoot, 'tasks.md');
+    const designPath = join(changeRoot, 'design.md');
+    return {
+        root: changeRoot,
+        proposal: (await pathExists(proposalPath)) ? proposalPath : null,
+        tasks: (await pathExists(tasksPath)) ? tasksPath : null,
+        design: (await pathExists(designPath)) ? designPath : null
+    };
+}
+async function buildSummary(id, changeRoot) {
+    const paths = await resolvePaths(changeRoot);
+    const specs = await listSpecs(changeRoot);
+    let taskProgress = null;
+    if (paths.tasks !== null) {
+        taskProgress = parseTaskProgress(await readText(paths.tasks));
+    }
+    return { id, paths, specs, taskProgress };
+}
+export async function scanOpenSpec(options = {}) {
+    const openspecRoot = options.openspecRoot ?? defaultOpenSpecRoot();
+    const changesRoot = join(openspecRoot, 'changes');
+    if (!(await isDirectory(openspecRoot))) {
+        return { openspecRoot, changesRoot, exists: false, changes: [] };
+    }
+    if (!(await isDirectory(changesRoot))) {
+        return { openspecRoot, changesRoot, exists: true, changes: [] };
+    }
+    const ids = await listDirectories(changesRoot);
+    const changes = await Promise.all(ids.map((id) => buildSummary(id, join(changesRoot, id))));
+    return { openspecRoot, changesRoot, exists: true, changes };
+}
+export async function loadOpenSpecChange(changeId, options = {}) {
+    const openspecRoot = options.openspecRoot ?? defaultOpenSpecRoot();
+    const changeRoot = join(openspecRoot, 'changes', changeId);
+    if (!(await isDirectory(changeRoot))) {
+        return null;
+    }
+    const summary = await buildSummary(changeId, changeRoot);
+    const proposal = summary.paths.proposal === null ? null : parseProposal(await readText(summary.paths.proposal));
+    return { ...summary, proposal };
+}

package/dist/src/services/openspec/openspec-types.d.ts

@@ -0,0 +1,39 @@
+export type OpenSpecProposal = {
+    why: string;
+    whatChanges: string[];
+    outOfScope: string[];
+    dependencies: string[];
+    risks: string[];
+    acceptanceCriteria: string[];
+};
+export type OpenSpecTaskSection = {
+    heading: string;
+    total: number;
+    done: number;
+};
+export type OpenSpecTaskProgress = {
+    totalTodo: number;
+    doneTodo: number;
+    sections: OpenSpecTaskSection[];
+};
+export type OpenSpecChangePaths = {
+    root: string;
+    proposal: string | null;
+    tasks: string | null;
+    design: string | null;
+};
+export type OpenSpecChangeSummary = {
+    id: string;
+    paths: OpenSpecChangePaths;
+    specs: string[];
+    taskProgress: OpenSpecTaskProgress | null;
+};
+export type OpenSpecChangeDetail = OpenSpecChangeSummary & {
+    proposal: OpenSpecProposal | null;
+};
+export type OpenSpecScanReport = {
+    openspecRoot: string;
+    changesRoot: string;
+    exists: boolean;
+    changes: OpenSpecChangeSummary[];
+};

package/dist/src/services/openspec/openspec-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/openspec/openspec-validate-service.d.ts

@@ -0,0 +1,27 @@
+import { type OpenSpecScanOptions } from './openspec-scan-service.js';
+export type OpenSpecValidationLevel = 'error' | 'warning';
+export type OpenSpecValidationIssue = {
+    level: OpenSpecValidationLevel;
+    rule: string;
+    message: string;
+};
+export type OpenSpecValidationSource = 'internal' | 'openspec-cli';
+export type OpenSpecValidationResult = {
+    changeId: string;
+    valid: boolean;
+    source: OpenSpecValidationSource;
+    issues: OpenSpecValidationIssue[];
+    cliOutput?: string;
+};
+export type ExternalRunnerOutcome = {
+    available: boolean;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+};
+export type ExternalRunner = (command: string, args: string[]) => Promise<ExternalRunnerOutcome>;
+export type OpenSpecValidateOptions = OpenSpecScanOptions & {
+    preferExternal?: boolean;
+    externalRunner?: ExternalRunner;
+};
+export declare function validateOpenSpecChange(changeId: string, options?: OpenSpecValidateOptions): Promise<OpenSpecValidationResult | null>;

package/dist/src/services/openspec/openspec-validate-service.js

@@ -0,0 +1,77 @@
+import { join } from 'node:path';
+import { isDirectory } from '../../shared/fs.js';
+import { loadOpenSpecChange } from './openspec-scan-service.js';
+const CHANGE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function defaultOpenSpecRoot() {
+    return join(process.cwd(), 'openspec');
+}
+async function defaultExternalRunner(_command, _args) {
+    return { available: false, exitCode: null, stdout: '', stderr: '' };
+}
+function buildInternalIssues(changeId, detail) {
+    const issues = [];
+    if (!CHANGE_ID_PATTERN.test(changeId)) {
+        issues.push({
+            level: 'error',
+            rule: 'change-id-format',
+            message: `changeId ${changeId} does not match [A-Za-z0-9][A-Za-z0-9._-]*`
+        });
+    }
+    if (detail === null || detail.proposal === null) {
+        issues.push({ level: 'error', rule: 'proposal-exists', message: 'proposal.md is missing' });
+        return issues;
+    }
+    const proposal = detail.proposal;
+    if (proposal.why.length === 0) {
+        issues.push({ level: 'warning', rule: 'why-non-empty', message: 'Why section is empty' });
+    }
+    if (proposal.whatChanges.length === 0) {
+        issues.push({ level: 'error', rule: 'what-changes-non-empty', message: 'What Changes section has no bullets' });
+    }
+    if (proposal.acceptanceCriteria.length === 0) {
+        issues.push({ level: 'error', rule: 'acceptance-non-empty', message: 'Acceptance Criteria section has no bullets' });
+    }
+    return issues;
+}
+function hasErrors(issues) {
+    return issues.some((issue) => issue.level === 'error');
+}
+async function runInternal(changeId, openspecRoot) {
+    const changeRoot = join(openspecRoot, 'changes', changeId);
+    if (!(await isDirectory(changeRoot))) {
+        return null;
+    }
+    const detail = await loadOpenSpecChange(changeId, { openspecRoot });
+    const issues = buildInternalIssues(changeId, detail);
+    return {
+        changeId,
+        valid: !hasErrors(issues),
+        source: 'internal',
+        issues
+    };
+}
+export async function validateOpenSpecChange(changeId, options = {}) {
+    const openspecRoot = options.openspecRoot ?? defaultOpenSpecRoot();
+    const runner = options.externalRunner ?? defaultExternalRunner;
+    if (options.preferExternal === true) {
+        const outcome = await runner('openspec', ['validate', changeId]);
+        if (outcome.available) {
+            const cliOutput = [outcome.stdout, outcome.stderr].filter((part) => part.length > 0).join('\n').trim();
+            const passed = outcome.exitCode === 0;
+            const issues = passed
+                ? []
+                : [{ level: 'error', rule: 'openspec-cli-failed', message: `openspec validate exited with code ${outcome.exitCode ?? 'null'}` }];
+            return { changeId, valid: passed, source: 'openspec-cli', issues, cliOutput };
+        }
+        const internal = await runInternal(changeId, openspecRoot);
+        if (internal === null) {
+            return null;
+        }
+        internal.issues = [
+            { level: 'warning', rule: 'openspec-cli-unavailable', message: 'openspec CLI not found, fell back to internal lint' },
+            ...internal.issues
+        ];
+        return internal;
+    }
+    return runInternal(changeId, openspecRoot);
+}

package/dist/src/services/perf/perf-baseline-service.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Performance baseline scaffolding for the RD stage.
+ *
+ * peaks-solo's RD stage runs before the QA stage. The user-facing pain is
+ * that performance tests (lighthouse / k6 / project-local benches / etc.)
+ * have historically only been run at QA Gate A4 — too late in the loop,
+ * because a slow regression discovered at QA triggers a return-to-rd
+ * cycle, the RD ships another "fix", QA re-runs, and the same cycle
+ * repeats up to 3 times before the slice ships.
+ *
+ * `peaks perf baseline` is the user-visible artifact of a deliberate
+ * compromise: keep the heavy performance measurement as something the
+ * RD runs themselves (lighthouse is project-shape dependent and we
+ * don't want to bake a lighthouse dependency into the CLI), but capture
+ * the result in a stable, scaffolded file under
+ * `.peaks/_runtime/<sid>/rd/perf-baseline.md` so QA Gate A4 has a known-good
+ * reference to diff against. The CLI itself only writes the scaffold
+ * and records the path; the actual measurement is a project-local
+ * concern that lives in the README, not in peaks-cli.
+ *
+ * The four-grounds check (per the skill-primary-CLI-auxiliary dev
+ * preference):
+ *   1. hook/script/CI invokability  — yes, a hook can call this CLI
+ *                                     to scaffold the file on session
+ *                                     init, similar to session bootstrap.
+ *   2. JSON envelope that gates a downstream decision — yes,
+ *                                     peaks-rd reads the result and
+ *                                     attaches it to the handoff.
+ *   3. Destructive --apply side effect — yes, default dry-run.
+ *   4. Machine-enforced gate that prose cannot enforce — no, the
+ *                                     measurement still lives in
+ *                                     the LLM / project tools. We do
+ *                                     NOT add a lint gate here.
+ *
+ * Net: CLI is justified. The destructive --apply default is dry-run,
+ * matching the rest of peaks-cli's scaffolding pattern.
+ */
+export type PerfBaselineInitOptions = {
+    projectRoot: string;
+    apply?: boolean;
+    reason?: string;
+};
+export type PerfBaselinePlan = {
+    apply: boolean;
+    projectRoot: string;
+    sessionId: string | null;
+    perfBaselinePath: string | null;
+    plannedWrites: Array<{
+        path: string;
+        kind: 'directory' | 'file';
+        bytes: number;
+        content: string;
+    }>;
+    alreadyInitialized: boolean;
+    existingFiles: string[];
+};
+export type PerfBaselineResult = PerfBaselinePlan & {
+    writtenFiles: string[];
+    createdDirectories: string[];
+    reason?: string;
+};
+export declare function executePerfBaselineInit(options: PerfBaselineInitOptions): Promise<PerfBaselineResult>;
+/**
+ * Re-exported so the CLI command can fall back to a project-root
+ * resolution when the caller did not pass --project. The CLI does
+ * the same findProjectRoot walk that `workspace init` does; this
+ * helper exists for the command layer to import without reaching
+ * into config-safety directly.
+ */
+export declare function resolveProjectRootFromCwd(cwd: string): string;