peaks-cli 1.0.12 → 1.0.13

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/recommendations/capability-seed-items.js

@@ -87,7 +87,7 @@ export const seedCapabilityItems = [
     capability('codegraph.semantic-query', 'codegraph', 'Codegraph Semantic Query', 'cli', 'project-analysis', ['engineer'], 'medium', 'peaks-rd-local-scan', 'Use local Grep/Glob and RD scanning when codegraph semantic query is unavailable.', 'Codegraph Semantic Query', 'Codegraph 语义查询', 'Queries local symbols and project relationships for RD planning evidence.', '查询本地符号和项目关系，为 RD 规划提供证据。'),
     capability('codegraph.impact-analysis', 'codegraph', 'Codegraph Impact Analysis', 'cli', 'impact-analysis', ['engineer', 'qa'], 'medium', 'peaks-rd-qa-impact-review', 'Use RD changed-file analysis and QA regression planning when codegraph affected output is unavailable.', 'Codegraph Impact Analysis', 'Codegraph 影响面分析', 'Analyzes likely impact for changed files so RD and QA can focus planning and regression scope.', '分析变更文件的可能影响面，帮助 RD 与 QA 聚焦规划和回归范围。'),
     capability('codegraph.context-pack', 'codegraph', 'Codegraph Context Pack', 'cli', 'context-pack', ['engineer', 'qa', 'product'], 'medium', 'peaks-txt-context-capsule', 'Use Peaks TXT context capsules and role-skill handoffs when codegraph context output is unavailable.', 'Codegraph Context Pack', 'Codegraph 上下文包', 'Builds task-specific local context that Solo, RD, and TXT can use as supporting evidence.', '生成任务相关的本地上下文，作为 Solo、RD 与 TXT 的辅助证据。'),
-    capability('gstack-browse.headed-browser-validation', 'gstack-browse', 'gstack Browse Headed Browser Validation', 'cli', 'browser-validation', ['engineer', 'qa'], 'medium', 'blocked-browser-validation', 'Block browser validation until headed gstack/browse/dist/browse can open the actual launched app URL.', 'gstack Browse Validation', 'gstack 有头浏览器验证', 'Validates UI flows in a visible gstack browse session against the app URL advertised by the launched dev server.', '使用有头 gstack browse 会话验证由开发服务器实际输出 URL 对应的 UI 流程。'),
+    capability('playwright-mcp.browser-validation', 'playwright-mcp', 'Playwright MCP Browser Validation', 'mcp', 'browser-validation', ['engineer', 'qa'], 'medium', 'manual-browser-test', 'Use local Playwright or manual browser verification.', 'Playwright Browser Validation', 'Playwright 浏览器验证', 'Validates UI flows through controlled browser automation.', '通过受控浏览器自动化验证 UI 流程。'),
     capability('chrome-devtools-mcp.browser-debug', 'chrome-devtools-mcp', 'Chrome DevTools Browser Debug', 'mcp', 'browser-debug', ['engineer', 'qa'], 'medium', 'manual-devtools-inspection', 'Use browser screenshots, console logs, and network traces supplied by the user.', 'Chrome DevTools Debug', 'Chrome DevTools 调试', 'Inspects runtime UI, console, network, and performance behavior.', '检查运行时 UI、控制台、网络和性能行为。'),
     capability('figma-context-mcp.design-context', 'figma-context-mcp', 'Figma Design Context', 'mcp', 'design-context', ['designer', 'engineer'], 'medium', 'manual-design-input', 'Ask the user for screenshots, tokens, or exported design notes.', 'Figma Design Context', 'Figma 设计上下文', 'Reads design context for UI implementation planning.', '读取设计上下文以辅助 UI 实现规划。'),
     capability('searchcode-mcp.code-search', 'searchcode-mcp', 'SearchCode MCP', 'mcp', 'code-search', ['engineer'], 'medium', 'local-code-search', 'Use local Grep/Glob and ask before sending private code externally.', 'External Code Search', '外部代码搜索', 'Searches code examples or repositories outside the current workspace.', '搜索当前工作区外部的代码示例或仓库。'),
@@ -100,6 +100,7 @@ export const seedCapabilityItems = [
     capability('gitnexus.repo-intelligence', 'gitnexus', 'GitNexus Repository Intelligence', 'cli', 'repo-intelligence', ['engineer'], 'medium', 'local-repo-scan', 'Use local project scanning through Peaks RD.', 'Repository Intelligence', '仓库智能分析', 'Repository intelligence should be proxied through Peaks before use.', '仓库智能分析应先通过 Peaks 代理边界再使用。'),
     capability('claude-code-best-practice.workflow-guidance', 'claude-code-best-practice', 'Claude Code Best Practice', 'doc', 'workflow-guidance', ['engineer'], 'low', 'peaks-built-in-rules', 'Use Peaks built-in workflow and review rules.', 'Claude Code Best Practice', 'Claude Code 最佳实践', 'Guidance for Claude Code engineering workflows.', 'Claude Code 工程工作流指导。'),
     capability('superpowers.workflow-methodology', 'superpowers', 'Superpowers Methodology', 'workflow', 'workflow-methodology', ['product', 'engineer'], 'low', 'peaks-workflow-route', 'Use Peaks route/autonomous plans.', 'Superpowers Methodology', 'Superpowers 方法论', 'Workflow and artifact methodology reference.', '工作流与 artifact 方法论参考。'),
+    capability('understand-anything.knowledge-graph', 'understand-anything', 'Understand Anything Knowledge Graph', 'skill', 'project-analysis', ['engineer', 'product', 'qa'], 'low', 'peaks-codegraph-or-rd-scan', 'Use peaks codegraph or peaks RD project scan when Understand Anything is not installed. Optionally suggest installing it via Claude Code: /plugin marketplace add Lum1104/Understand-Anything then /plugin install understand-anything.', 'Understand Anything Knowledge Graph', 'Understand Anything 知识图谱', 'Multi-agent project knowledge graph that Peaks reads from .understand-anything/knowledge-graph.json when it has been generated by the Understand Anything plugin in Claude Code.', '通过 Claude Code 的 Understand Anything 插件生成的多 agent 知识图谱，Peaks 在 .understand-anything/knowledge-graph.json 存在时读取它作为项目分析证据。'),
     capability('penpot.design-source', 'penpot', 'Penpot Design Source', 'doc', 'design-source', ['designer', 'engineer'], 'medium', 'manual-design-input', 'Ask for exported design notes or screenshots.', 'Penpot Design Source', 'Penpot 设计来源', 'Design-source reference for UI planning.', '用于 UI 规划的设计来源参考。'),
     capability('gstack.product-stack-guidance', 'gstack', 'Product Stack Guidance', 'doc', 'product-guidance', ['product'], 'low', 'peaks-prd', 'Use peaks-prd for product goals and non-goals.', 'Product Stack Guidance', '产品栈指导', 'Product and startup stack guidance reference.', '产品与创业栈指导参考。'),
     capability('awesome-design-md.design-reference', 'awesome-design-md', 'Design Markdown Reference', 'doc', 'design-reference', ['designer', 'engineer'], 'low', 'peaks-ui-visual-direction', 'Use peaks-ui to define visual direction and interaction constraints.', 'Design Reference', '设计参考', 'Design markdown examples and inspiration.', '设计 markdown 示例与灵感。'),

package/dist/src/services/recommendations/capability-seed-mappings.js

@@ -8,7 +8,7 @@ export const seedCapabilityLandingMappings = [
     mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-rd', skillName: 'peaks-rd', guidance: 'Dry-run reference only: peaks-rd may use peaks codegraph context --project <path> <task> to gather local evidence for RD analysis when execution is approved, without replacing standards dry-runs.' }),
     mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-solo', skillName: 'peaks-solo', guidance: 'Solo may attach local context packs or affected summaries before role handoff so RD, QA, and TXT share the same project evidence.' }),
     mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-txt', skillName: 'peaks-txt', guidance: 'TXT may summarize recorded codegraph context packs into handoffs while treating them as supporting evidence only.' }),
-    mapping({ capabilityId: 'gstack-browse.headed-browser-validation', sourceId: 'gstack-browse', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-qa', skillName: 'peaks-qa', guidance: 'Launch the app, capture its actual advertised URL, and validate only with headed gstack/browse/dist/browse; block instead of falling back to Playwright MCP or default ports.' }),
+    mapping({ capabilityId: 'playwright-mcp.browser-validation', sourceId: 'playwright-mcp', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-qa', skillName: 'peaks-qa', guidance: 'Use for browser and E2E validation after user-approved app targets are available.' }),
     mapping({ capabilityId: 'chrome-devtools-mcp.browser-debug', sourceId: 'chrome-devtools-mcp', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-ui', skillName: 'peaks-ui', guidance: 'Use for runtime UI, console, network, and performance inspection.' }),
     mapping({ capabilityId: 'context-mode.context-management', sourceId: 'context-mode', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-txt', skillName: 'peaks-txt', guidance: 'Use only for explicit context management; durable memory requires user opt-in.' }),
     mapping({ capabilityId: 'modelcontextprotocol-servers.collection', sourceId: 'modelcontextprotocol-servers', sourceGroup: 'access-repo', landingKind: 'catalog', target: 'future peaks mcp catalog', guidance: 'Treat as an unscanned MCP collection; do not auto-install unknown servers.' }),

package/dist/src/services/recommendations/capability-seed-sources.js

@@ -2,7 +2,7 @@ export const seedCapabilitySources = [
     { sourceId: 'ruflo-access-repo', sourceType: 'repo', sourceGroup: 'access-repo', title: 'Ruflo', url: 'https://github.com/ruvnet/ruflo', trustSignals: { notes: ['Workflow orchestration reference; do not execute or install from the capability map.'] }, discoveryStatus: 'unscanned', items: ['ruflo-access-repo.workflow-reference'] },
     { sourceId: 'context7', sourceType: 'repo', sourceGroup: 'access-repo', title: 'Context7', url: 'https://github.com/upstash/context7', trustSignals: { sourceReputation: 'commonly used docs lookup MCP capability' }, discoveryStatus: 'indexed', items: ['context7.docs-lookup'] },
     { sourceId: 'codegraph', sourceType: 'repo', sourceGroup: 'access-repo', title: 'codegraph', url: 'https://github.com/colbymchenry/codegraph', trustSignals: { notes: ['Use through peaks codegraph only; do not run upstream install flows from the capability map.', 'Local project indexing can create .codegraph artifacts; do not commit generated databases unless explicitly requested.'] }, discoveryStatus: 'indexed', items: ['codegraph.project-indexing', 'codegraph.semantic-query', 'codegraph.impact-analysis', 'codegraph.context-pack'] },
-    { sourceId: 'gstack-browse', sourceType: 'repo', sourceGroup: 'access-repo', title: 'gstack browse', url: 'https://github.com/garrytan/gstack', trustSignals: { notes: ['Use headed gstack/browse/dist/browse only after launching the app and discovering its actual advertised URL. Do not substitute Playwright MCP.'] }, discoveryStatus: 'indexed', items: ['gstack-browse.headed-browser-validation'] },
+    { sourceId: 'playwright-mcp', sourceType: 'repo', sourceGroup: 'access-repo', title: 'Playwright MCP', url: 'https://github.com/microsoft/playwright-mcp', trustSignals: { sourceReputation: 'Microsoft browser automation MCP server' }, discoveryStatus: 'indexed', items: ['playwright-mcp.browser-validation'] },
     { sourceId: 'chrome-devtools-mcp', sourceType: 'website', sourceGroup: 'access-repo', title: 'Chrome DevTools MCP', url: 'https://www.pulsemcp.com/servers/chrome-devtools', trustSignals: { notes: ['Browser inspection and performance debugging capability.'] }, discoveryStatus: 'indexed', items: ['chrome-devtools-mcp.browser-debug'] },
     { sourceId: 'context-mode', sourceType: 'repo', sourceGroup: 'access-repo', title: 'Context Mode', url: 'https://github.com/mksglu/context-mode', trustSignals: { notes: ['Context and memory management reference.'] }, discoveryStatus: 'indexed', items: ['context-mode.context-management'] },
     { sourceId: 'modelcontextprotocol-servers', sourceType: 'mcp-collection', sourceGroup: 'access-repo', title: 'Model Context Protocol Servers', url: 'https://github.com/modelcontextprotocol/servers', trustSignals: { sourceReputation: 'official MCP server collection' }, discoveryStatus: 'unscanned', items: ['modelcontextprotocol-servers.collection'] },

package/dist/src/services/shadcn/shadcn-service.d.ts

@@ -18,6 +18,10 @@ export type ShadcnExecutionResult = {
     stderr: string;
 };
 export type ShadcnProcessRunner = (invocation: ShadcnInvocation) => Promise<ShadcnExecutionResult>;
+declare function createShadcnEnvironment(sourceEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export declare function createShadcnInvocation(options: ShadcnInvocationOptions): ShadcnInvocation;
 export declare function executeShadcnInvocation(invocation: ShadcnInvocation, runner?: ShadcnProcessRunner): Promise<ShadcnExecutionResult>;
+export declare const testInternals: {
+    createShadcnEnvironment: typeof createShadcnEnvironment;
+};
 export {};

package/dist/src/services/shadcn/shadcn-service.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { win32 } from 'node:path';
+import { resolve } from 'node:path';
 const SHADCN_PACKAGE_NAME = 'shadcn';
 const SHADCN_PACKAGE_VERSION = '4.7.0';
 const SHADCN_EXECUTABLE = process.execPath;
@@ -10,15 +10,12 @@ const SHADCN_PROCESS_TIMEOUT_MS = 600_000;
 const SHADCN_OUTPUT_LIMIT_BYTES = 10 * 1024 * 1024;
 const POSITIONAL_ARGUMENT_PREFIX = '-';
 const PRESERVED_ENV_KEYS = ['PATH', 'Path', 'HOME', 'USERPROFILE', 'APPDATA', 'LOCALAPPDATA', 'TEMP', 'TMP', 'SystemRoot', 'WINDIR'];
-function assertShadcnBinaryExists(binaryPath) {
-    if (!existsSync(binaryPath)) {
-        throw new Error('Unable to resolve local shadcn binary from shadcn');
-    }
-}
 function resolveShadcnBinaryPath() {
     const require = createRequire(import.meta.url);
     const binaryPath = require.resolve('shadcn');
-    assertShadcnBinaryExists(binaryPath);
+    if (!existsSync(binaryPath)) {
+        throw new Error('Unable to resolve local shadcn binary from shadcn');
+    }
     return binaryPath;
 }
 function assertShadcnArgs(args) {
@@ -46,36 +43,24 @@ function assertOutputLimit(currentSize, chunkSize) {
     }
     return nextSize;
 }
-function getWindowsTaskkillPath(fileExists = existsSync) {
-    const candidates = [
-        win32.join('C:\\Windows', 'System32', 'taskkill.exe'),
-        win32.join('C:\\WINNT', 'System32', 'taskkill.exe')
-    ];
-    return candidates.find((candidate) => fileExists(candidate)) ?? null;
-}
-function terminateShadcnProcess(childProcess, platform = process.platform, killProcess = process.kill, spawnProcess = spawn, taskkillPath = getWindowsTaskkillPath()) {
+function terminateShadcnProcess(childProcess) {
     if (childProcess.pid === undefined) {
         childProcess.kill();
         return;
     }
-    if (platform === 'win32') {
-        if (!taskkillPath) {
-            childProcess.kill();
-            return;
-        }
-        const killerProcess = spawnProcess(taskkillPath, ['/pid', String(childProcess.pid), '/T', '/F'], { shell: false, stdio: 'ignore' });
-        killerProcess.on('error', () => childProcess.kill());
-        killerProcess.unref();
+    if (process.platform === 'win32') {
+        const taskkillPath = process.env.SystemRoot ? resolve(process.env.SystemRoot, 'System32', 'taskkill.exe') : 'taskkill.exe';
+        spawn(taskkillPath, ['/pid', String(childProcess.pid), '/T', '/F'], { shell: false, stdio: 'ignore' });
         return;
     }
     try {
-        killProcess(-childProcess.pid, 'SIGTERM');
+        process.kill(-childProcess.pid, 'SIGTERM');
     }
     catch {
         childProcess.kill('SIGTERM');
     }
 }
-function runShadcnProcess(invocation, timeoutMs = SHADCN_PROCESS_TIMEOUT_MS) {
+function defaultShadcnProcessRunner(invocation) {
     return new Promise((resolveResult, reject) => {
         const childProcess = spawn(invocation.executable, invocation.args, {
             cwd: invocation.cwd,
@@ -85,8 +70,8 @@ function runShadcnProcess(invocation, timeoutMs = SHADCN_PROCESS_TIMEOUT_MS) {
         });
         const timeout = setTimeout(() => {
             terminateShadcnProcess(childProcess);
-            reject(new Error(`shadcn process timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
+            reject(new Error(`shadcn process timed out after ${SHADCN_PROCESS_TIMEOUT_MS}ms`));
+        }, SHADCN_PROCESS_TIMEOUT_MS);
         const stdoutChunks = [];
         const stderrChunks = [];
         let stdoutSize = 0;
@@ -125,9 +110,6 @@ function runShadcnProcess(invocation, timeoutMs = SHADCN_PROCESS_TIMEOUT_MS) {
         });
     });
 }
-function defaultShadcnProcessRunner(invocation) {
-    return runShadcnProcess(invocation);
-}
 export function createShadcnInvocation(options) {
     assertShadcnArgs(options.args);
     return {
@@ -141,3 +123,6 @@ export function createShadcnInvocation(options) {
 export async function executeShadcnInvocation(invocation, runner = defaultShadcnProcessRunner) {
     return runner(invocation);
 }
+export const testInternals = {
+    createShadcnEnvironment
+};

package/dist/src/services/skills/skill-runbook-service.d.ts

@@ -0,0 +1,11 @@
+export type SkillRunbookInspection = {
+    name: string;
+    directory: string;
+    hasRunbook: boolean;
+    peaksCommandCount: number;
+    peaksCommandLines: string[];
+    destructiveApplyLines: string[];
+    hasAuthorizationNote: boolean;
+    ok: boolean;
+};
+export declare function inspectSkillRunbook(name: string, baseDir?: string): Promise<SkillRunbookInspection>;