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

package/dist/src/cli/commands/capability-commands.js

@@ -1,45 +0,0 @@
-import { readConfig } from '../../services/config/config-service.js';
-import { resolveCapabilityAvailability } from '../../services/recommendations/capability-availability.js';
-import { createCapabilityMapPlan } from '../../services/recommendations/capability-map-service.js';
-import { seedCapabilityItems, seedCapabilitySources } from '../../services/recommendations/seed-capability-catalog.js';
-import { fail, ok } from '../../shared/result.js';
-import { addJsonOption, printResult } from '../cli-helpers.js';
-const CAPABILITY_SOURCE_FILTERS = new Set(['all', 'access-repo', 'mcp-server']);
-export function registerCapabilityCommands(program, io) {
-    const capability = program.command('capability').description('Inspect Peaks capability catalog and runtime availability');
-    addJsonOption(capability.command("status").description("Show seed capability availability")).action((options) => runCapabilityStatus(io, options));
-    addCapabilityMapOptions(capability.command('map').description('Show dry-run external capability landing map')).action((options) => runCapabilityMap(io, options));
-    addCapabilityMapOptions(program.command('capabilities').description('Show dry-run external capability landing map')).action((options) => runCapabilityMap(io, options));
-}
-export function runCapabilityStatus(io, options) {
-    const availability = resolveCapabilityAvailability(seedCapabilityItems);
-    printResult(io, ok("capability.status", { sources: seedCapabilitySources, items: seedCapabilityItems, availability }), options.json);
-}
-function addCapabilityMapOptions(command) {
-    return addJsonOption(command.option('--source <source>', 'Filter source group: all, access-repo, or mcp-server', 'all'));
-}
-export function runCapabilityMap(io, options) {
-    const source = parseCapabilityMapSource(options.source);
-    if (!source) {
-        printResult(io, fail('capabilities.map', 'UNSUPPORTED_CAPABILITY_SOURCE', 'Supported capability sources are all, access-repo, and mcp-server', { source: options.source }, ['Rerun with --source all, --source access-repo, or --source mcp-server']), options.json);
-        process.exitCode = 1;
-        return;
-    }
-    const config = readConfig();
-    const installedCapabilityIds = getInstalledCapabilityIds(config);
-    const httpProxy = config.proxy?.httpProxy;
-    printResult(io, ok('capabilities.map', createCapabilityMapPlan({
-        source,
-        installedCapabilityIds,
-        ...(httpProxy === undefined ? {} : { httpProxy })
-    })), options.json);
-}
-export function getInstalledCapabilityIds(_config) {
-    return [];
-}
-export function parseCapabilityMapSource(source) {
-    if (CAPABILITY_SOURCE_FILTERS.has(source)) {
-        return source;
-    }
-    return null;
-}

package/dist/src/cli/commands/capability-worker-config-sc-commands.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-import type { ProgramIO } from '../cli-helpers.js';
-export declare function registerCapabilityWorkerConfigAndSCCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/capability-worker-config-sc-commands.js

@@ -1,10 +0,0 @@
-import { registerCapabilityCommands } from './capability-commands.js';
-import { registerConfigCommands } from './config-commands.js';
-import { registerSCCommands } from './sc-commands.js';
-import { registerWorkerCommands } from './worker-commands.js';
-export function registerCapabilityWorkerConfigAndSCCommands(program, io) {
-    registerCapabilityCommands(program, io);
-    registerWorkerCommands(program, io);
-    registerConfigCommands(program, io);
-    registerSCCommands(program, io);
-}

package/dist/src/cli/commands/classify-classify-commands.d.ts

@@ -1,19 +0,0 @@
-/**
- * peaks classify CLI (Slice L1a + L1b).
- *
- * Subcommands:
- *   - peaks classify run --project <path> [--override <level> --reason "<text>"]
- *     Classify the current diff via the heuristic + return a JSON envelope
- *     with the chosen level, gate set, and audit log.
- *   - peaks classify override --level <level> --reason "<text>" --project <path>
- *     Force a level; writes the override to the audit log.
- *   - peaks classify upgrade --level <level> --reason "<text>" --project <path>
- *     Same as override but explicitly framed as an upgrade (audit log
- *     records the upgrade event separately from override).
- *
- * Downgrade is REFUSED (per spec §4: "peaks classify downgrade" always
- * errors out). LLM may ask; the CLI never grants.
- */
-import { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerClassifyCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/classify-classify-commands.js

@@ -1,151 +0,0 @@
-/**
- * peaks classify CLI (Slice L1a + L1b).
- *
- * Subcommands:
- *   - peaks classify run --project <path> [--override <level> --reason "<text>"]
- *     Classify the current diff via the heuristic + return a JSON envelope
- *     with the chosen level, gate set, and audit log.
- *   - peaks classify override --level <level> --reason "<text>" --project <path>
- *     Force a level; writes the override to the audit log.
- *   - peaks classify upgrade --level <level> --reason "<text>" --project <path>
- *     Same as override but explicitly framed as an upgrade (audit log
- *     records the upgrade event separately from override).
- *
- * Downgrade is REFUSED (per spec §4: "peaks classify downgrade" always
- * errors out). LLM may ask; the CLI never grants.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { classifyTask } from '../../services/classify/classify-service.js';
-import { TASK_LEVELS } from '../../services/classify/classify-types.js';
-import { loadPreferences } from '../../services/preferences/preferences-service.js';
-import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-import { fail, ok } from '../../shared/result.js';
-const CLASSIFY_AUDIT_FILE = 'classify-audit.jsonl';
-function getSignalsFromGitDiff(projectRoot) {
-    // Use git diff --stat to extract file count + line count. Fall back to
-    // zeros if git is unavailable (e.g. fresh repo with no commits).
-    let stdout;
-    try {
-        const { execFileSync } = require('node:child_process');
-        stdout = execFileSync('git', ['diff', '--shortstat', 'HEAD'], {
-            cwd: projectRoot,
-            stdio: ['ignore', 'pipe', 'ignore'],
-            maxBuffer: 32 * 1024 * 1024,
-        }).toString('utf8');
-    }
-    catch {
-        return { filesChanged: 0, linesChanged: 0, touchesDependencies: false, touchesMigrationScripts: false, isPureRefactor: true, keywords: [] };
-    }
-    const lines = stdout.split('\n').filter((l) => l.trim().length > 0);
-    const filesChanged = lines.length;
-    let added = 0;
-    let removed = 0;
-    let touchesDependencies = false;
-    let touchesMigrationScripts = false;
-    for (const line of lines) {
-        const match = /(\d+)\s+insertion.*?(\d+)\s+deletion/.exec(line);
-        if (match) {
-            added += Number(match[1]);
-            removed += Number(match[2]);
-        }
-        if (/(package\.json|pnpm-lock\.yaml|yarn\.lock|requirements\.txt|go\.mod)/.test(line)) {
-            touchesDependencies = true;
-        }
-        if (/(migrate|codemod|backfill|schema)/.test(line)) {
-            touchesMigrationScripts = true;
-        }
-    }
-    // isPureRefactor: heuristic — if added lines / removed lines < 0.1 OR
-    // no new exports were added, treat as refactor. For L2.2 the signal is
-    // binary (true/false). Default: true (no behavior change is the safe
-    // assumption; flip to false when keyword 'add' / 'new' / 'feature' present).
-    const isPureRefactor = true;
-    return {
-        filesChanged,
-        linesChanged: added + removed,
-        touchesDependencies,
-        touchesMigrationScripts,
-        isPureRefactor,
-        keywords: [],
-    };
-}
-function appendAuditEntry(projectRoot, entry) {
-    const auditDir = join(projectRoot, '.peaks/_runtime');
-    if (!existsSync(auditDir)) {
-        try {
-            mkdirSync(auditDir, { recursive: true });
-        }
-        catch { /* ignore */ } // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-    }
-    const auditPath = join(auditDir, CLASSIFY_AUDIT_FILE);
-    let body = '';
-    try {
-        if (existsSync(auditPath)) {
-            body = readFileSync(auditPath, 'utf8');
-        }
-    }
-    catch { /* ignore */ } // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-    body += JSON.stringify(entry) + '\n';
-    try {
-        writeFileSync(auditPath, body);
-    }
-    catch { /* best-effort */ } // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-}
-function isTaskLevel(value) {
-    return TASK_LEVELS.includes(value);
-}
-export function registerClassifyCommands(program, io) {
-    const classify = program
-        .command('classify')
-        .description('L1a task classification: 5-level heuristic (typo/bug/feature/refactor/migration) + override/upgrade + audit log');
-    addJsonOption(classify
-        .command('run')
-        .description('Classify the current diff (git diff HEAD) into one of 5 task levels')
-        .requiredOption('--project <path>', 'target project root')
-        .option('--override <level>', 'force a level (one of typo|bug|feature|refactor|migration); requires --reason')
-        .option('--reason <text>', 'reason for the override (mandatory when --override is set)')).action(async (options) => {
-        try {
-            const prefs = await loadPreferences(options.project);
-            const signals = getSignalsFromGitDiff(options.project);
-            let override;
-            if (options.override !== undefined) {
-                if (!isTaskLevel(options.override)) {
-                    printResult(io, fail('classify.run', 'INVALID_LEVEL', `level must be one of: ${TASK_LEVELS.join(', ')}`, { provided: options.override }, ['Pass one of typo, bug, feature, refactor, migration']), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                if (options.reason === undefined || options.reason.length === 0) {
-                    printResult(io, fail('classify.run', 'REASON_REQUIRED', '--reason is required when --override is set', {}, ['Provide a non-empty reason for the override']), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                override = { level: options.override, reason: options.reason };
-            }
-            const result = classifyTask(override !== undefined
-                ? { signals, conservatism: prefs.classifyConservatism, override }
-                : { signals, conservatism: prefs.classifyConservatism }, prefs.classifyRules.feature_threshold_files, prefs.classifyRules.feature_threshold_lines);
-            appendAuditEntry(options.project, result.audit);
-            printResult(io, ok('classify.run', result, [], [
-                `gate set for level "${result.level}": ${result.gateSet.stages.join(', ')}`,
-                `audit log: .peaks/_runtime/${CLASSIFY_AUDIT_FILE}`,
-            ]), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('classify.run', 'CLASSIFY_RUN_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Run peaks classify --help for usage']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // Downgrade is REFUSED per spec §4. Surface this as a hard fail.
-    classify
-        .command('downgrade')
-        .description('REFUSED per spec §4 — peaks-loop never downgrades a classification; ask the user to override explicitly')
-        .requiredOption('--level <level>', 'attempted level')
-        .requiredOption('--reason <text>', 'reason for the attempt (always rejected)')
-        .requiredOption('--project <path>', 'target project root')
-        .option('--json', 'print machine-readable JSON envelope')
-        .action(async (options) => {
-        printResult(io, fail('classify.downgrade', 'DOWNGRADE_REFUSED', 'peaks classify downgrade is refused per spec §4. Use --override (with reason) on `classify run` to force a level; the CLI never downgrades a classification unilaterally.', { attemptedLevel: options.level, reason: options.reason }, ['Use `peaks classify run --override <level> --reason "<text>"` instead']), options.json);
-        process.exitCode = 2;
-    });
-}

package/dist/src/cli/commands/code-commands.d.ts

@@ -1,80 +0,0 @@
-/**
- * Slice 2 — `peaks code [--fast] <change-id>` (peaks-code fast mode).
- *
- * The `peaks-code` SKILL orchestrates an LLM-side workflow:
- *   load-memory -> standards-preflight -> rd-cycle -> qa-cycle -> emit-txt
- *
- * The CLI surface here is intentionally narrow: it builds a CodePlan and
- * runs it via `runCodeFast`. Fast mode skips memory full-load, standards
- * preflight, and the QA repair loop. Round-trip KPI: ≤ 30s.
- *
- * No new service layer — the orchestrator is the in-file `runCodeFast`
- * function. Hooks are injected so tests can mock at the boundary.
- *
- * v2.11.0 Group F (Tier 9) — D5 / D7 additions:
- *   - `peaks code should-pause --step <step> --mode <mode>` (D5)
- *   - `peaks code post-compact-detect --project <path>` (D7)
- */
-import type { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export type CodeStepKind = 'memory' | 'preflight' | 'rd' | 'qa' | 'emit';
-export interface CodeStep {
-    readonly id: 'load-memory' | 'standards-preflight' | 'rd-cycle' | 'qa-cycle' | 'emit-txt';
-    readonly kind: CodeStepKind;
-    readonly skipped: boolean;
-    /** QA-only: when true, qa hook retries on failure up to N rounds. */
-    readonly repairLoop?: boolean;
-}
-export interface CodePlan {
-    readonly sessionId: string;
-    readonly steps: readonly CodeStep[];
-}
-export interface CodeHooks {
-    readonly memory: (ctx: {
-        sessionId: string;
-    }) => Promise<unknown>;
-    readonly preflight: (ctx: {
-        sessionId: string;
-    }) => Promise<unknown>;
-    readonly rd: (ctx: {
-        sessionId: string;
-    }) => Promise<unknown>;
-    readonly qa: (ctx: {
-        sessionId: string;
-        repairLoop: boolean;
-    }) => Promise<unknown>;
-    readonly emit: (ctx: {
-        sessionId: string;
-    }) => Promise<unknown>;
-}
-export interface CodeRunResult {
-    readonly sessionId: string;
-    readonly ok: boolean;
-    readonly steps: readonly CodeStep[];
-    readonly skipped: readonly string[];
-    readonly elapsedMs: number;
-}
-/**
- * Build a CodePlan. `fast=true` marks memory + preflight as skipped and
- * disables the QA repair loop. Step order is fixed; emit-txt always last.
- */
-export declare function buildCodePlan(opts: {
-    sessionId: string;
-    fast: boolean;
-}): CodePlan;
-/**
- * Run the CodePlan. Skipped steps do NOT invoke their hook; emit-txt is
- * always invoked last. Returns timing + skipped ids for KPI measurement.
- */
-export declare function runCodeFast(opts: {
-    sessionId: string;
-    plan: CodePlan;
-    hooks: CodeHooks;
-}): Promise<CodeRunResult>;
-/**
- * Register the `peaks code [--fast] <change-id>` command. The actual
- * LLM-side orchestration is driven by the SKILL.md (LLM-side), so this
- * CLI command is a thin surface that builds the plan and emits a JSON
- * envelope for downstream tooling.
- */
-export declare function registerCodeCommands(program: Command, io: ProgramIO): void;