peaks-loop 4.1.2 → 4.1.4

package/dist/cli/commands/sop-lint-command.js

@@ -0,0 +1,64 @@
+// src/cli/commands/sop-lint-command.ts
+//
+// `peaks sop lint` — validate a SOP manifest. Split out of `sop-commands.ts`;
+// the verb name, its options, its envelope codes and its next-action strings
+// are unchanged.
+import { lintSop } from '../../services/sop/sop-service.js';
+import { addJsonOption, getErrorMessage } from '../cli-helpers.js';
+import { printSopFailure, printSopOk } from './sop-command-shared.js';
+/** The `sop.lint` envelope for a lint result, found or not. */
+function emitLintResult(io, options, result) {
+    if (result === null) {
+        printSopFailure(io, {
+            json: options.json,
+            command: 'sop.lint',
+            code: 'SOP_NOT_FOUND',
+            message: `No SOP found for id "${options.id}"`,
+            data: { id: options.id },
+            nextActions: ['Run peaks sop init --id <sop-id> --apply first']
+        });
+        return;
+    }
+    if (result.ok) {
+        printSopOk(io, { json: options.json, command: 'sop.lint', data: result });
+        return;
+    }
+    printSopFailure(io, {
+        json: options.json,
+        command: 'sop.lint',
+        code: 'SOP_LINT_FAILED',
+        message: `${result.findings.filter((f) => f.severity === 'error').length} lint error(s) in SOP "${options.id}"`,
+        data: result,
+        nextActions: ['Fix the reported findings, then re-run peaks sop lint']
+    });
+}
+async function runSopLint(io, options) {
+    try {
+        const lintOptions = { id: options.id };
+        if (options.allowCommands === true) {
+            lintOptions.allowCommands = true;
+        }
+        if (options.project !== undefined) {
+            lintOptions.projectRoot = options.project;
+        }
+        emitLintResult(io, options, await lintSop(lintOptions));
+    }
+    catch (error) {
+        printSopFailure(io, {
+            json: options.json,
+            command: 'sop.lint',
+            code: 'SOP_LINT_ERROR',
+            message: getErrorMessage(error),
+            data: { id: options.id },
+            nextActions: ['Check the SOP id before retrying']
+        });
+    }
+}
+export function registerSopLintCommand(sop, io) {
+    addJsonOption(sop
+        .command('lint')
+        .description('Validate a SOP manifest (id namespace, phases, gate ids, check fields)')
+        .requiredOption('--id <sop-id>', 'SOP id to lint')
+        .option('--allow-commands', 'permit command-type gates (they run shell-less processes)')
+        .option('--project <path>', 'lint the project-layer SOP (<path>/.peaks/sops) instead of global')).action((options) => runSopLint(io, options));
+}

package/dist/cli/commands/sop-register-command.d.ts

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

package/dist/cli/commands/sop-register-command.js

@@ -0,0 +1,48 @@
+// src/cli/commands/sop-register-command.ts
+//
+// `peaks sop register` — validate a SOP and record its gates in the gate
+// registry. Split out of `sop-commands.ts`; the verb name, its options, its
+// envelope fields and its next-action strings are unchanged.
+import { registerSop, SopRegisterError } from '../../services/sop/sop-registry-service.js';
+import { addJsonOption, getErrorMessage } from '../cli-helpers.js';
+import { printSopFailure, printSopOk } from './sop-command-shared.js';
+async function runSopRegister(io, options) {
+    try {
+        const registerOptions = { id: options.id };
+        if (options.allowCommands === true) {
+            registerOptions.allowCommands = true;
+        }
+        if (options.dryRun === true) {
+            registerOptions.dryRun = true;
+        }
+        if (options.project !== undefined) {
+            registerOptions.projectRoot = options.project;
+        }
+        const result = await registerSop(registerOptions);
+        printSopOk(io, {
+            json: options.json,
+            command: 'sop.register',
+            data: result,
+            nextActions: result.applied ? [] : ['Re-run without --dry-run to write registry.json']
+        });
+    }
+    catch (error) {
+        printSopFailure(io, {
+            json: options.json,
+            command: 'sop.register',
+            code: error instanceof SopRegisterError ? error.code : 'SOP_REGISTER_FAILED',
+            message: getErrorMessage(error),
+            data: { id: options.id },
+            nextActions: ['Run peaks sop lint to see why the SOP is not registrable']
+        });
+    }
+}
+export function registerSopRegisterCommand(sop, io) {
+    addJsonOption(sop
+        .command('register')
+        .description('Validate a SOP and record its gates in the gate registry (global, or --project for the repo)')
+        .requiredOption('--id <sop-id>', 'SOP id to register')
+        .option('--allow-commands', 'permit command-type gates when validating')
+        .option('--dry-run', 'preview the registration without writing registry.json')
+        .option('--project <path>', 'register into the repo (<path>/.peaks/sops, committed & team-shared) instead of global')).action((options) => runSopRegister(io, options));
+}

package/dist/cli/commands/sop-registry-command.d.ts

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

package/dist/cli/commands/sop-registry-command.js

@@ -0,0 +1,30 @@
+// src/cli/commands/sop-registry-command.ts
+//
+// `peaks sop registry` — list registered SOPs and gates. Split out of
+// `sop-commands.ts`; the verb name, its options, its envelope fields and its
+// next-action strings are unchanged.
+import { readRegistry } from '../../services/sop/sop-registry-service.js';
+import { addJsonOption, getErrorMessage } from '../cli-helpers.js';
+import { printSopFailure, printSopOk } from './sop-command-shared.js';
+async function runSopRegistry(io, options) {
+    try {
+        const registry = await readRegistry(options.project);
+        printSopOk(io, { json: options.json, command: 'sop.registry', data: registry });
+    }
+    catch (error) {
+        printSopFailure(io, {
+            json: options.json,
+            command: 'sop.registry',
+            code: 'SOP_REGISTRY_FAILED',
+            message: getErrorMessage(error),
+            data: {},
+            nextActions: ['The global registry may be corrupted; inspect ~/.peaks/sops/registry.json']
+        });
+    }
+}
+export function registerSopRegistryCommand(sop, io) {
+    addJsonOption(sop
+        .command('registry')
+        .description('List registered SOPs and gates (global; merges in the cwd project layer by default)')
+        .option('--project <path>', 'also include and prefer the repo layer (<path>/.peaks/sops) (default: current directory)', '.')).action((options) => runSopRegistry(io, options));
+}

package/dist/cli/commands/statusline-command-shared.d.ts

@@ -0,0 +1,73 @@
+import type { IdeId } from '../../services/ide/ide-types.js';
+import type { StatusLineScope } from '../../services/skills/statusline-settings-service.js';
+export declare const STDIN_READ_TIMEOUT_MS = 250;
+/**
+ * Read piped stdin if present; resolve quickly with '' when attached to a TTY.
+ *
+ * `PEAKS_STATUSLINE_STDIN` is a test seam (same shape as the `PEAKS_HOOK_STDIN`
+ * seam in `gate-commands.ts`): the harness payload is the only channel that
+ * carries the harness's own context numbers, and a test that cannot supply one
+ * cannot verify the capture at all.
+ *
+ * WHY THIS SEAM IS ACCEPTABLE ON A DIFFERENT ARGUMENT (repair cycle 3). The
+ * precedent does not transfer by itself: `PEAKS_HOOK_STDIN` is defended in
+ * `.peaks/memory/peaks-hook-stdin-test-seam-pattern.md` because its payload
+ * still routes through the `enforceBashCommand` SOP gate. This payload is
+ * routed through no gate — it is PERSISTED verbatim as the record the witness
+ * guard then reads. So the compensating control is different, not absent: the
+ * record is observation-only and one-way. It reaches only `data` and the
+ * `warnings` / `nextActions` arrays of `peaks code context-now`; the compact
+ * `action` there is computed from `probe.ratio` alone, before and independently
+ * of the witness. A forged payload can therefore make the instrument lie —
+ * measured: a hand-written record yields a confident false `agree`, or a
+ * self-contradictory false `disagree` — and can do nothing else. What it cannot
+ * do is fire, block or delay a compact. Unconditional rather than NODE_ENV-
+ * gated, for the reason already recorded for the sibling seam.
+ */
+export declare function readStdin(): Promise<string>;
+export declare function resolveScope(options: {
+    global?: boolean;
+}): StatusLineScope;
+/** `--project <path>`, else the nearest project root, else cwd — unchanged order. */
+export declare function resolveProjectRoot(project: string | undefined): string;
+/**
+ * Resolve the IDE the install should target. The CLI user can override with
+ * `--ide <id>`. Otherwise we delegate to `detectIdeFromContext` which checks
+ * `process.env[adapter.envVar]` → stdin shape → cwd `.trae`/`.claude` →
+ * fallback `'claude-code'`. Pass `parsedStdin: null` since `peaks statusline
+ * install` is not invoked from inside an IDE hook — there's no stdin payload.
+ */
+export declare function resolveIdeForCommand(options: {
+    ide?: string;
+}, projectRoot: string | undefined): IdeId;
+export type InstallOptions = {
+    global?: boolean;
+    project?: string;
+    force?: boolean;
+    dryRun?: boolean;
+    json?: boolean;
+    ide?: string;
+};
+export type UninstallOptions = {
+    global?: boolean;
+    project?: string;
+    json?: boolean;
+    ide?: string;
+};
+export type StatusOptions = {
+    global?: boolean;
+    project?: string;
+    json?: boolean;
+    ide?: string;
+};
+export type RenderOptions = {
+    project?: string;
+    json?: boolean;
+    now?: number | string;
+};
+export type CompactOptions = {
+    project?: string;
+    sessionId?: string;
+    json?: boolean;
+    now?: number | string;
+};

package/dist/cli/commands/statusline-command-shared.js

@@ -0,0 +1,90 @@
+// src/cli/commands/statusline-command-shared.ts
+//
+// What every `peaks statusline *` verb shares: the stdin seam, the install
+// scope, the IDE resolution, and the option shapes the verbs declare. Split
+// out of `statusline-commands.ts`; every value and every resolution order is
+// unchanged.
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { detectIdeFromContext } from '../../services/ide/hook-translator.js';
+export const STDIN_READ_TIMEOUT_MS = 250;
+/**
+ * Read piped stdin if present; resolve quickly with '' when attached to a TTY.
+ *
+ * `PEAKS_STATUSLINE_STDIN` is a test seam (same shape as the `PEAKS_HOOK_STDIN`
+ * seam in `gate-commands.ts`): the harness payload is the only channel that
+ * carries the harness's own context numbers, and a test that cannot supply one
+ * cannot verify the capture at all.
+ *
+ * WHY THIS SEAM IS ACCEPTABLE ON A DIFFERENT ARGUMENT (repair cycle 3). The
+ * precedent does not transfer by itself: `PEAKS_HOOK_STDIN` is defended in
+ * `.peaks/memory/peaks-hook-stdin-test-seam-pattern.md` because its payload
+ * still routes through the `enforceBashCommand` SOP gate. This payload is
+ * routed through no gate — it is PERSISTED verbatim as the record the witness
+ * guard then reads. So the compensating control is different, not absent: the
+ * record is observation-only and one-way. It reaches only `data` and the
+ * `warnings` / `nextActions` arrays of `peaks code context-now`; the compact
+ * `action` there is computed from `probe.ratio` alone, before and independently
+ * of the witness. A forged payload can therefore make the instrument lie —
+ * measured: a hand-written record yields a confident false `agree`, or a
+ * self-contradictory false `disagree` — and can do nothing else. What it cannot
+ * do is fire, block or delay a compact. Unconditional rather than NODE_ENV-
+ * gated, for the reason already recorded for the sibling seam.
+ */
+export function readStdin() {
+    const override = process.env['PEAKS_STATUSLINE_STDIN'];
+    if (override !== undefined) {
+        return Promise.resolve(override);
+    }
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+            resolve('');
+            return;
+        }
+        let data = '';
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(data);
+        };
+        const timer = setTimeout(finish, STDIN_READ_TIMEOUT_MS);
+        timer.unref?.();
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => {
+            clearTimeout(timer);
+            finish();
+        });
+        process.stdin.on('error', () => {
+            clearTimeout(timer);
+            finish();
+        });
+    });
+}
+export function resolveScope(options) {
+    return options.global ? 'global' : 'project';
+}
+/** `--project <path>`, else the nearest project root, else cwd — unchanged order. */
+export function resolveProjectRoot(project) {
+    return project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+}
+/**
+ * Resolve the IDE the install should target. The CLI user can override with
+ * `--ide <id>`. Otherwise we delegate to `detectIdeFromContext` which checks
+ * `process.env[adapter.envVar]` → stdin shape → cwd `.trae`/`.claude` →
+ * fallback `'claude-code'`. Pass `parsedStdin: null` since `peaks statusline
+ * install` is not invoked from inside an IDE hook — there's no stdin payload.
+ */
+export function resolveIdeForCommand(options, projectRoot) {
+    if (options.ide !== undefined && options.ide.length > 0) {
+        return options.ide;
+    }
+    return detectIdeFromContext({
+        env: process.env,
+        cwd: projectRoot ?? process.cwd(),
+        parsedStdin: null
+    });
+}

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

@@ -1,22 +1,4 @@
 import type { Command } from 'commander';
 import { type ProgramIO } from '../cli-helpers.js';
-type RenderOptions = {
-    project?: string;
-    json?: boolean;
-    now?: number | string;
-};
-/**
- * Default-statusline render body. Reused by both the top-level default
- * action (Bug-02 dispatch) and the explicit `render` subcommand. Exported
- * so a unit test can exercise the JSON / text output paths without going
- * through commander.
- *
- * Capability resolution is delegated to {@link resolveStatusLineCapability}
- * with only `env` and `isTTY` — the env-driven path is the single first-
- * version source of truth. No CLI flag widens the surface. The model
- * itself is read-only: `buildStatusLineModel` is the sole I/O boundary,
- * and it now also resolves compact state.
- */
-export declare function runDefaultStatuslineRender(options: RenderOptions, io: ProgramIO): Promise<void>;
 export declare function registerStatusLineCommands(program: Command, io: ProgramIO): void;
-export {};
+export { runDefaultStatuslineRender } from './statusline-render-command.js';