peaks-cli 1.3.4 → 1.3.6

package/dist/src/cli/commands/progress-watch-render.js

@@ -1,308 +0,0 @@
-/**
- * In-place progress renderer for `peaks progress watch`.
- *
- * Goals (in order of importance):
- *   1. **In-place overwrite.** Every tick the dynamic rows
- *      (status line + progress bar) get rewritten, NOT
- *      appended. We bypass `io.stdout` (which is
- *      `console.log` and adds a trailing `\n` per call) and
- *      write directly to `process.stdout`. The cursor-up
- *      and erase-line escapes are the same ones terminal-kit
- *      emits; we do not need a terminal-kit dependency for
- *      them.
- *   2. **Clear PEAKS-CLI branding.** A static 3-line header
- *      with the brand bar, the project root, and the
- *      progress-file path is painted once. The user always
- *      sees what they are looking at, even after the
- *      watch loop has overwritten the dynamic rows a
- *      thousand times.
- *   3. **Graceful degrade.** When stdout is not a TTY
- *      (CI / pipe / `--json`), we fall back to a single
- *      static snapshot per tick (no cursor moves, no
- *      SGR colour) and a single newline. This keeps the
- *      tool scriptable without dropping into a wall of
- *      escape codes.
- *
- * Token-cost note: this module is rendered to the user's
- * terminal, never into LLM context. The watch side has
- * zero token cost.
- */
-import chalk from 'chalk';
-// ─────────────────────────────────────────────────────────────────────
-// Raw byte writes. We do NOT go through `io.stdout` because the
-// default `io.stdout` is `console.log` and appends a trailing
-// newline, which would defeat in-place overwrite.
-// ─────────────────────────────────────────────────────────────────────
-function rawWrite(text) {
-    process.stdout.write(text);
-}
-/**
- * Number of lines that the dynamic dashboard occupies. We
- * rewrite exactly this many rows per tick via cursor-up +
- * erase-line, so the static header above and the
- * `press Ctrl-C` footer below stay put.
- */
-const DYNAMIC_LINES = 2;
-/** ANSI: cursor up N rows. */
-const CURSOR_UP_N = (n) => `\x1b[${n}A`;
-/** ANSI: erase the current row from cursor to end-of-line. */
-const ERASE_LINE = '\x1b[2K';
-/** ANSI: reset all SGR attributes. */
-const RESET = '\x1b[0m';
-const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-const PHASE_LABEL = {
-    starting: 'starting',
-    running: 'running',
-    verifying: 'verifying',
-    completing: 'completing',
-    finished: 'finished',
-    failed: 'failed',
-    idle: 'idle'
-};
-const PHASE_COLOR = {
-    starting: chalk.cyan,
-    running: chalk.cyan,
-    verifying: chalk.cyan,
-    completing: chalk.cyan,
-    finished: chalk.green,
-    failed: chalk.red,
-    idle: chalk.gray
-};
-function pickSpinnerFrame(tick) {
-    return SPINNER_FRAMES[Math.abs(tick) % SPINNER_FRAMES.length];
-}
-function formatElapsed(ms) {
-    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-    const hours = Math.floor(totalSeconds / 3600);
-    const minutes = Math.floor((totalSeconds % 3600) / 60);
-    const seconds = totalSeconds % 60;
-    if (hours > 0) {
-        return `${hours}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
-    }
-    return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
-}
-/**
- * `elapsedMs` based fake progress, 0..1, capped at 1 after
- * 10 minutes. Visual cue that the watch is alive; NOT a real
- * percent-complete.
- */
-function computeFakeProgress(data) {
-    if (data === null)
-        return 0;
-    const startedAtMs = new Date(data.current.startedAt).getTime();
-    if (Number.isNaN(startedAtMs))
-        return 0;
-    const elapsedMs = Math.max(0, Date.now() - startedAtMs);
-    const upperBoundMs = 10 * 60 * 1000;
-    return Math.min(1, elapsedMs / upperBoundMs);
-}
-// ─────────────────────────────────────────────────────────────────────
-// ASCII art for the PEAKS-CLI brand bar. Kept in code (not a
-// dependency) so the user sees the brand even when terminal-kit
-// is unavailable.
-// ─────────────────────────────────────────────────────────────────────
-/**
- * Three-row ASCII wordmark for PEAKS-CLI. Each letter is 5
- * columns wide; P-E-A-K-S take 5 letters (25 cols), the
- * dash takes 9 cols (with surrounding space), C-L-I take 3
- * letters (15 cols). Total ≈ 49 cols, fits in 80-col
- * terminals without wrapping.
- *
- * The block-character density (full blocks on the
- * prominent rows) makes the brand visually dominant
- * against the gray "sub-agent progress watch" tagline
- * that sits below — so the user always knows whose
- * dashboard they are looking at, even when the title
- * bar is hidden.
- */
-const PEAKS_CLI_ASCII = [
-    '█████  █████  █████  ██  ██  ██████         █████  ██      ███',
-    '█   █  █   █  █   █ ██  ██    ██             ██    ██      ██ ',
-    '█████  █████  █████  ██████    ██             ████  █████   ███'
-];
-/**
- * Render the static header: the three-line big PEAKS-CLI
- * wordmark, a separator, a small "sub-agent progress watch"
- * tagline, and the project / file path. Painted ONCE at the
- * top of the watch, then never touched again.
- *
- * Visual hierarchy (per user feedback):
- *   1. PEAKS-CLI — 3-line big block art, bold cyan
- *   2. separator
- *   3. sub-agent progress watch — 1 line, smaller, gray
- *   4. project / path — 1 line each, gray
- */
-function renderHeader(projectRoot, progressFilePath, isTty) {
-    if (!isTty) {
-        // Non-TTY: emit a single header line, no colour. The
-        // dashboard still emits 2 dynamic lines per tick, so
-        // consumers that need to parse the output can rely on
-        // a known line count.
-        return [
-            `PEAKS-CLI · sub-agent progress watch · project=${projectRoot}`,
-            `path: ${progressFilePath}`
-        ].join('\n') + '\n';
-    }
-    // PEAKS-CLI block-art rows in bold cyan (the "big" brand).
-    const brandLines = PEAKS_CLI_ASCII.map((row) => chalk.bold.cyan(`  ${row}`));
-    // The tagline below the brand — small, gray, no big
-    // chrome. The user sees the brand first, the
-    // descriptor second.
-    const tagline = chalk.gray('  sub-agent progress watch');
-    const projLine = chalk.gray(`  project: ${projectRoot}`);
-    const pathLine = chalk.gray(`  path:    ${progressFilePath}`);
-    const separator = chalk.gray('  ' + '─'.repeat(60));
-    return [
-        brandLines[0] ?? '',
-        brandLines[1] ?? '',
-        brandLines[2] ?? '',
-        separator,
-        tagline,
-        projLine,
-        pathLine,
-        ''
-    ].join('\n');
-}
-/**
- * Render the 2-line dynamic dashboard. Status row on top
- * (spinner + phase + elapsed + step), progress bar on the
- * bottom. When `data` is null (no progress file yet), we
- * still show a live spinner + a "waiting…" message so the
- * user knows the watch is alive.
- */
-function renderDynamicRows(data, tick, width, isTty) {
-    const progressFraction = computeFakeProgress(data);
-    if (data === null) {
-        return {
-            status: isTty
-                ? `  ${chalk.gray(pickSpinnerFrame(tick))}  ${chalk.gray('idle')}    ${chalk.gray('(no progress file yet — sub-agent has not started)')}`
-                : `idle (no progress file yet)`,
-            bar: isTty ? renderBar(0, width, isTty) : ''
-        };
-    }
-    const startedAtMs = new Date(data.current.startedAt).getTime();
-    const elapsedMs = Number.isNaN(startedAtMs) ? 0 : Math.max(0, Date.now() - startedAtMs);
-    const phase = PHASE_LABEL[data.current.phase];
-    const step = data.current.step.length > 60 ? data.current.step.slice(0, 57) + '...' : data.current.step;
-    const verdict = data.current.verdict ? `  verdict=${data.current.verdict}` : '';
-    const role = data.role ? `  role=${data.role}` : '';
-    const spinner = pickSpinnerFrame(tick);
-    if (!isTty) {
-        return {
-            status: `${spinner} ${phase} ${formatElapsed(elapsedMs)} ${step}${role}${verdict}`,
-            bar: ''
-        };
-    }
-    const colorize = PHASE_COLOR[data.current.phase] ?? chalk.cyan;
-    const spinnerColor = phase === 'failed' ? chalk.red
-        : phase === 'finished' ? chalk.green
-            : chalk.cyan;
-    const statusLine = `  ${spinnerColor(spinner)}  ${colorize(phase.padEnd(11))}  ${chalk.yellow(formatElapsed(elapsedMs))}  ${step}${chalk.gray(role)}${verdict ? chalk.gray(verdict) : ''}`;
-    return {
-        status: statusLine,
-        bar: renderBar(progressFraction, width, isTty)
-    };
-}
-function renderBar(fraction, width, isTty) {
-    if (!isTty)
-        return '';
-    // 8ths-of-cell block characters: ░ (empty) U+2591, full blocks
-    // U+2588..U+258F for the partial last cell.
-    const barCells = Math.max(10, Math.min(50, Math.floor(width * 0.4)));
-    const filled = Math.round(barCells * Math.max(0, Math.min(1, fraction)) * 8);
-    const fullBlocks = Math.floor(filled / 8);
-    const fracBlock = filled % 8;
-    const emptyCells = barCells * 8 - filled;
-    const fullStr = '█'.repeat(fullBlocks);
-    const fracStr = fracBlock > 0 ? String.fromCharCode(0x2588 + (8 - fracBlock)) : '';
-    const emptyStr = '░'.repeat(Math.floor(emptyCells / 8));
-    const percent = String(Math.round(fraction * 100)).padStart(3, ' ');
-    return `  ${chalk.green(fullStr + fracStr + emptyStr)}  ${chalk.gray(`${percent}%`)}`;
-}
-export class WatchRenderer {
-    projectRoot;
-    progressFilePath;
-    width;
-    isTty;
-    hasRenderedDynamic = false;
-    constructor(options) {
-        this.projectRoot = options.projectRoot;
-        this.progressFilePath = options.progressFilePath;
-        this.width = (process.stdout.columns ?? 120) - 1;
-        this.isTty = process.stdout.isTTY === true;
-    }
-    /**
-     * Paint the static header once at the top of the watch
-     * (the PEAKS-CLI wordmark, separator, project, path). Then
-     * paint the dynamic rows for the first tick. From here on
-     * the dynamic rows are the only thing we touch.
-     */
-    start() {
-        rawWrite(renderHeader(this.projectRoot, this.progressFilePath, this.isTty));
-        this.paintDynamicOnce(null, 0);
-    }
-    /**
-     * Repaint the 2 dynamic rows in place. First call moves
-     * the cursor up N rows from the bottom of the previously
-     * painted block; subsequent calls do the same.
-     */
-    tick(data, tickCount) {
-        if (this.hasRenderedDynamic) {
-            // Move cursor up to the top of the previously-painted
-            // dynamic block.
-            rawWrite(CURSOR_UP_N(DYNAMIC_LINES));
-        }
-        this.paintDynamicOnce(data, tickCount);
-    }
-    paintDynamicOnce(data, tick) {
-        const { status, bar } = renderDynamicRows(data, tick, this.width, this.isTty);
-        // Erase-then-rewrite the status row.
-        rawWrite(ERASE_LINE + status + '\n');
-        // Erase-then-rewrite the bar row. (In non-TTY mode the
-        // bar is empty; we still emit a newline so the line
-        // count stays consistent.)
-        rawWrite(ERASE_LINE + bar + '\n');
-        this.hasRenderedDynamic = true;
-    }
-    /**
-     * Paint a final 2-line verdict + a farewell line below the
-     * dashboard, then return. The cursor stays at the bottom
-     * of the farewell so the user's shell prompt lands on the
-     * next row.
-     */
-    finalize(data) {
-        // Rewrite the dynamic block one last time so the user can
-        // read the verdict.
-        if (this.hasRenderedDynamic) {
-            rawWrite(CURSOR_UP_N(DYNAMIC_LINES));
-        }
-        this.paintDynamicOnce(data, Number.MAX_SAFE_INTEGER);
-        // Then emit the farewell BELOW the dashboard, in green.
-        const verdictSuffix = data.current.verdict !== undefined ? ` (verdict=${data.current.verdict})` : '';
-        const farewell = this.isTty
-            ? chalk.green(`✔ peaks progress watch: sub-agent reached phase=${data.current.phase}${verdictSuffix} at ${new Date().toISOString()}. Auto-closing watch window.`)
-            : `peaks progress watch: sub-agent reached phase=${data.current.phase}${verdictSuffix} at ${new Date().toISOString()}. Auto-closing watch window.`;
-        rawWrite(ERASE_LINE + farewell + '\n');
-    }
-    /**
-     * Force a non-ANSI snapshot of the current state, used by
-     * the `--once` mode and for fallback when stdout is not a
-     * TTY. Does NOT touch the cursor state — safe to call from
-     * any context.
-     */
-    static snapshot(data) {
-        return renderDynamicRows(data, 0, 80, false);
-    }
-}
-/**
- * Strip ANSI escapes from a string. Used for visible-length
- * accounting; not for re-painting.
- */
-export function stripAnsi(input) {
-    // eslint-disable-next-line no-control-regex
-    return input.replace(/\x1b\[[0-9;]*m/g, '');
-}
-/** Reset terminal SGR — used on early-return error paths. */
-export function resetTerminal() {
-    rawWrite(RESET);
-}

package/dist/src/services/mcp/mcp-apply-service.d.ts

@@ -1,31 +0,0 @@
-import { type PlanMcpInstallOptions, type McpInstallEnvCheck } from './mcp-plan-service.js';
-export type McpApplyAction = 'add' | 'update' | 'claimed' | 'noop';
-export type McpApplyBackupInfo = {
-    path: string | null;
-    skipped: boolean;
-};
-export type McpApplyResult = {
-    capabilityId: string;
-    action: McpApplyAction;
-    backup: McpApplyBackupInfo;
-    written: {
-        settingsPath: string;
-        managedMarkerPath: string;
-    };
-    envCheck: McpInstallEnvCheck;
-};
-export type McpApplyOptions = PlanMcpInstallOptions & {
-    claim?: boolean;
-    backupRoot?: string;
-    clock?: () => string;
-};
-export type McpRollbackOptions = {
-    backupPath: string;
-    globalSettingsPath?: string;
-};
-export type McpRollbackResult = {
-    restoredFrom: string;
-    restoredTo: string;
-};
-export declare function applyMcpInstall(capabilityId: string, options?: McpApplyOptions): Promise<McpApplyResult>;
-export declare function rollbackMcpInstall(options: McpRollbackOptions): Promise<McpRollbackResult>;

package/dist/src/services/mcp/mcp-apply-service.js

@@ -1,112 +0,0 @@
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { pathExists, readText } from '../../shared/fs.js';
-import { planMcpInstall } from './mcp-plan-service.js';
-function defaultGlobalSettingsPath() {
-    return join(homedir(), '.claude', 'settings.json');
-}
-function defaultManagedMarkerPath() {
-    return join(homedir(), '.peaks', 'mcp-managed.json');
-}
-function defaultBackupRoot() {
-    return join(homedir(), '.peaks-artifacts', 'mcp-backups');
-}
-function defaultClock() {
-    return new Date().toISOString().replace(/[:.]/g, '-');
-}
-async function readJsonFile(path) {
-    if (!(await pathExists(path))) {
-        return {};
-    }
-    const raw = await readText(path);
-    if (raw.length === 0) {
-        return {};
-    }
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return {};
-    }
-    return parsed;
-}
-async function writeJsonFile(path, data) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
-}
-function buildServerConfig(spec) {
-    const env = {};
-    for (const key of spec.envKeys) {
-        env[key] = `\${${key}}`;
-    }
-    return { command: spec.command, args: [...spec.args], env };
-}
-async function createBackup(settingsPath, backupRoot, timestamp) {
-    if (!(await pathExists(settingsPath))) {
-        return null;
-    }
-    const backupPath = join(backupRoot, timestamp, 'settings.json');
-    await mkdir(dirname(backupPath), { recursive: true });
-    await writeFile(backupPath, await readText(settingsPath), 'utf8');
-    return backupPath;
-}
-async function updateManagedMarker(markerPath, name) {
-    const marker = await readJsonFile(markerPath);
-    const existing = Array.isArray(marker.servers)
-        ? marker.servers.filter((entry) => typeof entry === 'string')
-        : [];
-    if (!existing.includes(name)) {
-        existing.push(name);
-    }
-    await writeJsonFile(markerPath, { ...marker, servers: existing });
-}
-export async function applyMcpInstall(capabilityId, options = {}) {
-    const plan = await planMcpInstall(capabilityId, options);
-    if (plan.action === 'unknown-capability' || plan.spec === null) {
-        throw new Error(`No MCP install spec registered for capability ${capabilityId} (unknown-capability)`);
-    }
-    if (plan.envCheck.missing.length > 0) {
-        throw new Error(`Refusing to apply: missing required env vars: ${plan.envCheck.missing.join(', ')}`);
-    }
-    if (plan.action === 'conflict' && options.claim !== true) {
-        throw new Error(`Refusing to apply: server ${plan.spec.name} exists but is not peaks-managed (conflict). Re-run with --claim to take ownership.`);
-    }
-    const settingsPath = options.globalSettingsPath ?? defaultGlobalSettingsPath();
-    const markerPath = options.managedMarkerPath ?? defaultManagedMarkerPath();
-    const backupRoot = options.backupRoot ?? defaultBackupRoot();
-    const clock = options.clock ?? defaultClock;
-    if (plan.action === 'noop') {
-        return {
-            capabilityId,
-            action: 'noop',
-            backup: { path: null, skipped: true },
-            written: { settingsPath, managedMarkerPath: markerPath },
-            envCheck: plan.envCheck
-        };
-    }
-    const backupPath = await createBackup(settingsPath, backupRoot, clock());
-    const settings = await readJsonFile(settingsPath);
-    const existingServers = settings.mcpServers !== null && typeof settings.mcpServers === 'object' && !Array.isArray(settings.mcpServers)
-        ? settings.mcpServers
-        : {};
-    const nextServers = { ...existingServers, [plan.spec.name]: buildServerConfig(plan.spec) };
-    await writeJsonFile(settingsPath, { ...settings, mcpServers: nextServers });
-    await updateManagedMarker(markerPath, plan.spec.name);
-    const action = plan.action === 'conflict' ? 'claimed' : plan.action;
-    return {
-        capabilityId,
-        action,
-        backup: { path: backupPath, skipped: false },
-        written: { settingsPath, managedMarkerPath: markerPath },
-        envCheck: plan.envCheck
-    };
-}
-export async function rollbackMcpInstall(options) {
-    if (!(await pathExists(options.backupPath))) {
-        throw new Error(`Refusing to rollback: backup file not found at ${options.backupPath}`);
-    }
-    const target = options.globalSettingsPath ?? defaultGlobalSettingsPath();
-    const content = await readText(options.backupPath);
-    await mkdir(dirname(target), { recursive: true });
-    await writeFile(target, content, 'utf8');
-    return { restoredFrom: options.backupPath, restoredTo: target };
-}

package/dist/src/services/mcp/mcp-call-service.d.ts

@@ -1,17 +0,0 @@
-import { type McpInstallSpec } from './mcp-install-registry.js';
-import { type McpClientTransport } from './mcp-client-service.js';
-export type McpCallTransportFactory = (spec: McpInstallSpec, env: Record<string, string | undefined>) => McpClientTransport;
-export type McpCallOptions = {
-    capabilityId: string;
-    toolName: string;
-    transportFactory: McpCallTransportFactory;
-    args?: Record<string, unknown>;
-    env?: Record<string, string | undefined>;
-    timeoutMs?: number;
-};
-export type McpCallResult = {
-    capabilityId: string;
-    toolName: string;
-    result: unknown;
-};
-export declare function callMcpTool(options: McpCallOptions): Promise<McpCallResult>;

package/dist/src/services/mcp/mcp-call-service.js

@@ -1,34 +0,0 @@
-import { findMcpInstallSpec } from './mcp-install-registry.js';
-import { createMcpClient } from './mcp-client-service.js';
-function checkRequiredEnv(spec, env) {
-    return spec.envKeys.filter((key) => {
-        const value = env[key];
-        return value === undefined || value.length === 0;
-    });
-}
-export async function callMcpTool(options) {
-    const spec = findMcpInstallSpec(options.capabilityId);
-    if (spec === null) {
-        throw new Error(`No MCP install spec registered for capability ${options.capabilityId}`);
-    }
-    const env = options.env ?? process.env;
-    const missing = checkRequiredEnv(spec, env);
-    if (missing.length > 0) {
-        throw new Error(`Refusing to call ${spec.name}: missing required env vars: ${missing.join(', ')}`);
-    }
-    const transport = options.transportFactory(spec, env);
-    const clientOptions = options.timeoutMs !== undefined
-        ? { transport, timeoutMs: options.timeoutMs }
-        : { transport };
-    const client = createMcpClient(clientOptions);
-    try {
-        const result = await client.request('tools/call', {
-            name: options.toolName,
-            arguments: options.args ?? {}
-        });
-        return { capabilityId: options.capabilityId, toolName: options.toolName, result };
-    }
-    finally {
-        await client.close();
-    }
-}

package/dist/src/services/mcp/mcp-client-service.d.ts

@@ -1,14 +0,0 @@
-export type McpClientTransport = {
-    send: (line: string) => Promise<void>;
-    onLine: (handler: (line: string) => void) => void;
-    close: () => Promise<void>;
-};
-export type McpClientOptions = {
-    transport: McpClientTransport;
-    timeoutMs?: number;
-};
-export type McpClientHandle = {
-    request: (method: string, params?: unknown) => Promise<unknown>;
-    close: () => Promise<void>;
-};
-export declare function createMcpClient(options: McpClientOptions): McpClientHandle;

package/dist/src/services/mcp/mcp-client-service.js

@@ -1,49 +0,0 @@
-import { buildRequest, parseMessages, serializeMessage } from './mcp-protocol.js';
-const DEFAULT_TIMEOUT_MS = 30000;
-export function createMcpClient(options) {
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    let nextId = 1;
-    let buffer = '';
-    const pending = new Map();
-    function deliver(message) {
-        const entry = pending.get(message.id);
-        if (entry === undefined) {
-            return;
-        }
-        pending.delete(message.id);
-        clearTimeout(entry.timer);
-        if (message.error !== undefined) {
-            entry.reject(new Error(`MCP error ${message.error.code}: ${message.error.message}`));
-            return;
-        }
-        entry.resolve(message.result);
-    }
-    options.transport.onLine((line) => {
-        buffer += line;
-        const { messages, remainder } = parseMessages(buffer);
-        buffer = remainder;
-        for (const message of messages) {
-            deliver(message);
-        }
-    });
-    async function request(method, params) {
-        const id = nextId++;
-        const message = serializeMessage(buildRequest(id, method, params));
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                pending.delete(id);
-                reject(new Error(`MCP request ${method} timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-            pending.set(id, { resolve, reject, timer });
-            options.transport.send(message).catch((error) => {
-                clearTimeout(timer);
-                pending.delete(id);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            });
-        });
-    }
-    async function close() {
-        await options.transport.close();
-    }
-    return { request, close };
-}

package/dist/src/services/mcp/mcp-install-registry.d.ts

@@ -1,11 +0,0 @@
-import type { McpServerScope } from './mcp-types.js';
-export type McpInstallSpec = {
-    capabilityId: string;
-    name: string;
-    scope: McpServerScope;
-    command: string;
-    args: string[];
-    envKeys: string[];
-};
-export declare const seedMcpInstalls: ReadonlyArray<McpInstallSpec>;
-export declare function findMcpInstallSpec(capabilityId: string): McpInstallSpec | null;

package/dist/src/services/mcp/mcp-install-registry.js

@@ -1,38 +0,0 @@
-export const seedMcpInstalls = [
-    {
-        capabilityId: 'context7.docs-lookup',
-        name: 'context7',
-        scope: 'global',
-        command: 'npx',
-        args: ['-y', '@upstash/context7-mcp@latest'],
-        envKeys: ['CONTEXT7_API_KEY']
-    },
-    {
-        capabilityId: 'playwright-mcp.browser-validation',
-        name: 'playwright',
-        scope: 'global',
-        command: 'npx',
-        args: ['-y', '@playwright/mcp@latest'],
-        envKeys: []
-    },
-    {
-        capabilityId: 'chrome-devtools-mcp.browser-debug',
-        name: 'chrome-devtools',
-        scope: 'global',
-        command: 'npx',
-        args: ['-y', 'chrome-devtools-mcp@latest'],
-        envKeys: []
-    },
-    {
-        capabilityId: 'figma-context-mcp.design-context',
-        name: 'figma',
-        scope: 'global',
-        command: 'npx',
-        args: ['-y', 'figma-developer-mcp@latest', '--stdio'],
-        envKeys: ['FIGMA_API_KEY']
-    }
-];
-export function findMcpInstallSpec(capabilityId) {
-    const match = seedMcpInstalls.find((spec) => spec.capabilityId === capabilityId);
-    return match ?? null;
-}

package/dist/src/services/mcp/mcp-plan-service.d.ts

@@ -1,29 +0,0 @@
-import { type McpScanOptions } from './mcp-scan-service.js';
-import { type McpInstallSpec } from './mcp-install-registry.js';
-import type { McpServerConfig } from './mcp-types.js';
-export type McpInstallAction = 'add' | 'update' | 'noop' | 'conflict' | 'unknown-capability';
-export type McpInstallEnvCheck = {
-    missing: string[];
-};
-export type McpInstallDiffEntry<T> = {
-    before: T;
-    after: T;
-};
-export type McpInstallDiff = {
-    command?: McpInstallDiffEntry<string>;
-    args?: McpInstallDiffEntry<string[]>;
-    envKeys?: McpInstallDiffEntry<string[]>;
-};
-export type McpInstallPlan = {
-    capabilityId: string;
-    action: McpInstallAction;
-    spec: McpInstallSpec | null;
-    current: McpServerConfig | null;
-    envCheck: McpInstallEnvCheck;
-    diff: McpInstallDiff | null;
-    nextActions: string[];
-};
-export type PlanMcpInstallOptions = McpScanOptions & {
-    env?: Record<string, string | undefined>;
-};
-export declare function planMcpInstall(capabilityId: string, options?: PlanMcpInstallOptions): Promise<McpInstallPlan>;