peaks-loop 4.0.0-beta.8 → 4.0.0-beta.9

package/dist/services/openspec/openspec-bridge-service.js

@@ -0,0 +1,76 @@
+import { readText } from '../../shared/fs.js';
+import { loadOpenSpecChange } from './openspec-scan-service.js';
+function splitTaskSections(markdown) {
+    const sections = [];
+    let current = null;
+    for (const line of markdown.split(/\r?\n/)) {
+        if (line.startsWith('## ')) {
+            if (current !== null) {
+                sections.push(current);
+            }
+            current = { heading: line.slice(3).trim(), body: [] };
+        }
+        else if (current !== null) {
+            current.body.push(line);
+        }
+    }
+    if (current !== null) {
+        sections.push(current);
+    }
+    return sections;
+}
+const TODO_PATTERN = /^- \[ \] (.+?)\s*$/;
+const DONE_PATTERN = /^- \[[xX]\] (.+?)\s*$/;
+function extractItems(body) {
+    const todos = [];
+    const doneItems = [];
+    for (const rawLine of body) {
+        const line = rawLine.trim();
+        const todoMatch = TODO_PATTERN.exec(line);
+        if (todoMatch !== null) {
+            todos.push(todoMatch[1]);
+            continue;
+        }
+        const doneMatch = DONE_PATTERN.exec(line);
+        if (doneMatch !== null) {
+            doneItems.push(doneMatch[1]);
+        }
+    }
+    return { todos, doneItems };
+}
+async function buildCommitBoundaries(tasksPath) {
+    if (tasksPath === null) {
+        return [];
+    }
+    const markdown = await readText(tasksPath);
+    const boundaries = [];
+    for (const section of splitTaskSections(markdown)) {
+        const { todos, doneItems } = extractItems(section.body);
+        if (todos.length === 0 && doneItems.length === 0) {
+            continue;
+        }
+        boundaries.push({ heading: section.heading, todos, doneItems });
+    }
+    return boundaries;
+}
+export async function projectOpenSpecToRdInput(changeId, options = {}) {
+    const detail = await loadOpenSpecChange(changeId, options);
+    if (detail === null) {
+        return null;
+    }
+    const acceptance = detail.proposal?.acceptanceCriteria ?? [];
+    const whatChanges = detail.proposal?.whatChanges ?? [];
+    const dependencies = detail.proposal?.dependencies ?? [];
+    const risks = detail.proposal?.risks ?? [];
+    const outOfScope = detail.proposal?.outOfScope ?? [];
+    const commitBoundaries = await buildCommitBoundaries(detail.paths.tasks);
+    return {
+        changeId,
+        acceptance,
+        whatChanges,
+        dependencies,
+        risks,
+        outOfScope,
+        commitBoundaries
+    };
+}

package/dist/services/openspec/openspec-init-service.d.ts

@@ -0,0 +1,23 @@
+export type OpenSpecInitOptions = {
+    projectRoot: string;
+    apply?: boolean;
+};
+export type OpenSpecInitPlan = {
+    apply: boolean;
+    projectRoot: string;
+    openspecRoot: string;
+    plannedWrites: Array<{
+        path: string;
+        kind: 'directory' | 'file';
+        bytes: number;
+        content: string;
+    }>;
+    alreadyInitialized: boolean;
+    existingFiles: string[];
+};
+export type OpenSpecInitResult = OpenSpecInitPlan & {
+    writtenFiles: string[];
+    createdDirectories: string[];
+};
+export declare function planOpenSpecInit(options: OpenSpecInitOptions): Promise<OpenSpecInitPlan>;
+export declare function executeOpenSpecInit(options: OpenSpecInitOptions): Promise<OpenSpecInitResult>;

package/dist/services/openspec/openspec-init-service.js

@@ -0,0 +1,122 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isDirectory, pathExists } from '../../shared/fs.js';
+const README_BODY = `# OpenSpec — change proposals for this project
+
+This directory hosts the \`peaks openspec\` change proposal lifecycle:
+
+  render → validate → show → to-rd → ... → archive
+
+Each in-flight proposal lives in \`changes/<id>/\` and contains:
+
+- \`proposal.md\`  — why, what, non-goals, impact
+- \`tasks.md\`     — concrete slices and commit boundaries (consumed by peaks-sc)
+- \`design.md\`   — optional, for non-trivial designs
+- \`specs/\`       — optional, delta-style spec changes (## ADDED / ## MODIFIED / ## REMOVED)
+- \`*.md\`         — any additional narrative the change needs
+
+When a change ships, \`peaks openspec archive <id> --apply\` moves it into
+\`changes/archive/<id>/\`. The archive is the historical record of what
+landed and why.
+
+To scaffold a fresh change in this project:
+
+  peaks openspec render --request <path-to-render-request.json> --apply
+
+For the full lifecycle see \`peaks openspec --help\` and the
+peaks-clause-code skill family.
+`;
+const CHANGES_INDEX_HEADER = `# OpenSpec — change log
+
+This file is the human-readable index of every change that has shipped in
+this project. New entries are added by \`peaks openspec archive\` (when
+\`.apply\` is used); do not hand-edit.
+
+| Date | Change | Status |
+|------|--------|--------|
+`;
+function renderReadme() {
+    return README_BODY;
+}
+function renderChangesIndex() {
+    return CHANGES_INDEX_HEADER;
+}
+function buildPlan(projectRoot, apply) {
+    const openspecRoot = join(projectRoot, 'openspec');
+    const changesRoot = join(openspecRoot, 'changes');
+    const archiveRoot = join(changesRoot, 'archive');
+    const plannedWrites = [
+        { path: openspecRoot, kind: 'directory', bytes: 0, content: '' },
+        { path: changesRoot, kind: 'directory', bytes: 0, content: '' },
+        { path: archiveRoot, kind: 'directory', bytes: 0, content: '' },
+        { path: join(openspecRoot, 'README.md'), kind: 'file', bytes: 0, content: renderReadme() },
+        { path: join(openspecRoot, 'CHANGES.md'), kind: 'file', bytes: 0, content: renderChangesIndex() }
+    ];
+    // Stamp byte counts now that content is finalised.
+    for (const write of plannedWrites) {
+        if (write.kind === 'file') {
+            write.bytes = Buffer.byteLength(write.content, 'utf8');
+        }
+    }
+    return {
+        apply,
+        projectRoot,
+        openspecRoot,
+        plannedWrites,
+        alreadyInitialized: false,
+        existingFiles: []
+    };
+}
+export async function planOpenSpecInit(options) {
+    const openspecRoot = join(options.projectRoot, 'openspec');
+    const plan = buildPlan(options.projectRoot, options.apply ?? false);
+    if (await isDirectory(openspecRoot)) {
+        // Already initialised. Report the existing files so the user can audit
+        // before re-running with --apply. We never overwrite an existing
+        // openspec/ — that is a destructive action and out of scope for init.
+        const existing = [];
+        for (const write of plan.plannedWrites) {
+            if (write.kind === 'file' && (await pathExists(write.path))) {
+                existing.push(write.path);
+            }
+        }
+        // Pre-compute which directory writes to keep (those whose target does
+        // not exist yet). .filter cannot be async, so resolve the boolean
+        // set up front.
+        const directoryKeep = new Set();
+        for (const write of plan.plannedWrites) {
+            if (write.kind === 'directory' && !(await isDirectory(write.path))) {
+                directoryKeep.add(write.path);
+            }
+        }
+        plan.plannedWrites = plan.plannedWrites.filter((write) => {
+            if (write.kind === 'directory')
+                return directoryKeep.has(write.path);
+            return !existing.includes(write.path);
+        });
+        plan.alreadyInitialized = existing.length > 0 || (await isDirectory(join(openspecRoot, 'changes')));
+        plan.existingFiles = existing;
+    }
+    return plan;
+}
+export async function executeOpenSpecInit(options) {
+    const plan = await planOpenSpecInit(options);
+    const writtenFiles = [];
+    const createdDirectories = [];
+    if (plan.apply && !plan.alreadyInitialized) {
+        for (const write of plan.plannedWrites) {
+            if (write.kind === 'directory') {
+                if (!(await isDirectory(write.path))) {
+                    await mkdir(write.path, { recursive: true });
+                    createdDirectories.push(write.path);
+                }
+                continue;
+            }
+            if (write.content.length === 0)
+                continue;
+            await writeFile(write.path, write.content, 'utf8');
+            writtenFiles.push(write.path);
+        }
+    }
+    return { ...plan, writtenFiles, createdDirectories };
+}

package/dist/services/openspec/openspec-propose-from-doctor-service.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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-loop 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.
+ */
+export interface DoctorFinding {
+    readonly id: string;
+    readonly rule: string;
+    readonly detail: string;
+    readonly severity: 'pass' | 'warn' | 'fail';
+}
+export interface ProposeFromDoctorInput {
+    readonly projectRoot: string;
+    readonly finding: DoctorFinding;
+    /** Optional clock for testability. */
+    readonly clock?: () => string;
+}
+export interface ProposeFromDoctorResult {
+    readonly changeId: string;
+    readonly changeDir: string;
+    readonly proposalPath: string;
+    readonly created: boolean;
+}
+export declare function proposeFromDoctor(input: ProposeFromDoctorInput): ProposeFromDoctorResult;

package/dist/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-loop 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/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/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/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/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/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[];
+};