peaks-loop 4.0.0-beta → 4.0.0-beta.10

package/dist/cli/commands/bee-commands.js

@@ -0,0 +1,169 @@
+/**
+ * peaks bee * CLI — M7 (spec §7A.2 / §10 RL-9 / AC-24 / AC-25 / AC-26).
+ *
+ * Adds:
+ *   peaks bee export --bee <id> --out <path.tar.gz>
+ *   peaks bee import --in <path.tar.gz> [--as <bee-name>]
+ *
+ * The bee-side counterparts of the loop-side `peaks loop export /
+ * import`. Same hard rules:
+ *
+ *   - source `shareable=false` blocks export at the CLI layer.
+ *   - bundle lands as `candidate`; promotion to `stable` requires
+ *     an `evolution_evaluation` row with an independent
+ *     `evaluator_id` (see `peaks evolution evaluate`).
+ *
+ * The bee bundle captures the bee's inline manifest/segment/file/change
+ * rows so the receiver can re-materialize the full bee + any
+ * loop↔bee relations that referenced it + any evidence briefs that
+ * touched it.
+ *
+ * The `peaks skill sediment export / import` alias lives in
+ * `src/cli/commands/skill-sediment.ts` for one release cycle.
+ */
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from '../../shared/result.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { openStateDb } from '../../services/skillhub/sqlite-store.js';
+import { writeBundle, BundleNotShareableError, BundleAssetNotFoundError, } from '../../services/share/bundle-writer.js';
+import { readBundle, BundleMajorVersionMismatchError, BundleSchemaVersionsMismatchError, BundleImportToStableForbiddenError, BundleMalformedError, } from '../../services/share/bundle-reader.js';
+export function registerBeeCommands(program, io) {
+    // Reuse the existing `bee` parent if one is registered; the
+    // add-a-new-subcommand-check-for-existing-top-level-first rule.
+    const existing = program.commands.find((c) => c.name() === 'bee');
+    const bee = existing ?? program
+        .command('bee')
+        .description('M7: peaks bee export / import (spec §7A.2 / §10 RL-9)');
+    // ---------- peaks bee export ----------
+    addJsonOption(bee
+        .command('export')
+        .description("M7: export a bee_release as a peaks.bundle/1 tarball (spec §7A.2). Refuses to export when shareable=false.")
+        .requiredOption('--bee <id>', 'bee_release numeric id (use `peaks asset status --bee <name>` to find the id)')
+        .requiredOption('--out <path>', 'output .tar.gz path')
+        .option('--project <path>', 'target project root (defaults to cwd)')).action((options) => {
+        const asJson = options.json === true;
+        const beeId = Number(options.bee);
+        if (!Number.isInteger(beeId) || beeId <= 0) {
+            printResult(io, fail('bee.export', 'INVALID_BEE_ID', `--bee must be a positive integer (got '${options.bee}')`, { bee: options.bee }, [
+                'Re-run with --bee <numeric-id>.',
+            ]), asJson);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+            if (!existsSync(join(projectRoot, '.peaks'))) {
+                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
+            }
+            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
+            try {
+                const result = writeBundle({
+                    db,
+                    blobsDir: join(projectRoot, '.peaks', 'blobs'),
+                    kind: 'bee',
+                    id: beeId,
+                    outPath: options.out,
+                });
+                printResult(io, ok('bee.export', {
+                    outPath: result.outPath,
+                    kind: result.kind,
+                    assetId: result.assetId,
+                    importedAs: 'candidate',
+                }, [], [
+                    `Receiver must run \`peaks bee import --in ${result.outPath}\` to land this bundle, then run an independent evolution_evaluation before any promote.`,
+                ]), asJson);
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch (error) {
+            if (error instanceof BundleNotShareableError) {
+                printResult(io, fail('bee.export', error.code, error.message, { bee: options.bee }, [
+                    'Set shareable=true on the bee_release row, or stop sharing.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof BundleAssetNotFoundError) {
+                printResult(io, fail('bee.export', error.code, error.message, { bee: options.bee }, [
+                    'Verify the bee id with `peaks asset status --bee <name>`.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(io, fail('bee.export', 'BEE_EXPORT_FAILED', getErrorMessage(error), { bee: options.bee }, ['Verify --bee id and --out path.']), asJson);
+            process.exitCode = 1;
+        }
+    });
+    // ---------- peaks bee import ----------
+    addJsonOption(bee
+        .command('import')
+        .description('M7: import a peaks.bundle/1 tarball. Lands as candidate only — promotion requires an evolution_evaluation row (spec §7A.2 / AC-25 / AC-26).')
+        .requiredOption('--in <path>', 'input .tar.gz path')
+        .option('--as <name>', 'optional rename for the bee name when landing')
+        .option('--project <path>', 'target project root (defaults to cwd)')).action((options) => {
+        const asJson = options.json === true;
+        try {
+            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+            if (!existsSync(join(projectRoot, '.peaks'))) {
+                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
+            }
+            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
+            try {
+                const result = readBundle({
+                    db,
+                    blobsDir: join(projectRoot, '.peaks', 'blobs'),
+                    inPath: options.in,
+                    ...(options.as !== undefined ? { asName: options.as } : {}),
+                });
+                printResult(io, ok('bee.import', {
+                    assetId: result.assetId,
+                    kind: result.kind,
+                    importedAs: result.importedAs,
+                    warnings: result.warnings,
+                    evidenceBriefCount: result.evidenceBriefCount,
+                }, result.warnings, [
+                    `Run an independent evaluation against this release before promoting; peaks bee promote refuses without an evolution_evaluation row.`,
+                ]), asJson);
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch (error) {
+            if (error instanceof BundleMajorVersionMismatchError) {
+                printResult(io, fail('bee.import', error.code, error.message, { receivedMajor: error.receivedMajor }, [
+                    'Use the matching peaks.bundle/<major> reader; this peaks build only supports major=1.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof BundleSchemaVersionsMismatchError) {
+                printResult(io, fail('bee.import', error.code, error.message, {}, [
+                    'Source bundle did not declare the canonical schema versions; refuse the bundle.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof BundleImportToStableForbiddenError) {
+                printResult(io, fail('bee.import', error.code, error.message, {}, [
+                    'Bundles always land as candidate; promotion to stable requires an evolution_evaluation row (AC-26).',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof BundleMalformedError) {
+                printResult(io, fail('bee.import', error.code, error.message, { inPath: options.in }, [
+                    'Re-export from the source via `peaks bee export`.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(io, fail('bee.import', 'BEE_IMPORT_FAILED', getErrorMessage(error), { inPath: options.in }, ['Verify the bundle path and integrity.']), asJson);
+            process.exitCode = 1;
+        }
+    });
+}

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

@@ -0,0 +1,80 @@
+/**
+ * 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;