peaks-cli 1.0.28 → 1.1.1

package/dist/src/cli/commands/core-artifact-commands.js

@@ -227,11 +227,11 @@ export function registerCoreAndArtifactCommands(program, io) {
     const memory = program.command('memory').description('Manage project-local Peaks memory');
     addJsonOption(memory
         .command('extract')
-        .description('Extract stable project memory from skill artifacts into project .claude/memory')
+        .description('Extract stable project memory from skill artifacts into project .peaks/memory')
         .requiredOption('--project <path>', 'target project root')
         .requiredOption('--artifact <path...>', 'skill artifact paths inside the project')
         .option('--dry-run', 'preview writes without changing files', true)
-        .option('--apply', 'write extracted memories into project .claude/memory')).action((options) => {
+        .option('--apply', 'write extracted memories into project .peaks/memory')).action((options) => {
         try {
             const result = executeProjectMemoryExtract({ projectRoot: options.project, artifactPaths: options.artifact, apply: options.apply === true });
             printResult(io, ok('memory.extract', summarizeProjectMemoryExtractResult(result)), options.json);
@@ -243,11 +243,11 @@ export function registerCoreAndArtifactCommands(program, io) {
     });
     addJsonOption(memory
         .command('sync')
-        .description('Back up project .claude/memory into the artifact workspace')
+        .description('Back up project .peaks/memory into the artifact workspace')
         .requiredOption('--project <path>', 'target project root')
         .requiredOption('--workspace <path>', 'artifact workspace path')
         .option('--dry-run', 'preview copies without changing files', true)
-        .option('--apply', 'copy project .claude/memory into artifact workspace backup')).action((options) => {
+        .option('--apply', 'copy project .peaks/memory into artifact workspace backup')).action((options) => {
         try {
             const result = executeProjectMemoryBackup({ projectRoot: options.project, artifactWorkspacePath: options.workspace, apply: options.apply === true });
             printResult(io, ok('memory.sync', summarizeProjectMemoryBackupResult(result)), options.json);

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

@@ -1,15 +1,8 @@
 import { loadProjectDashboard } from '../../services/dashboard/project-dashboard-service.js';
-import { generateProjectContext, loadOntology, readProjectContext, upsertDecision, upsertModule } from '../../services/memory/project-context-service.js';
+import { generateProjectContext, readProjectContext } from '../../services/memory/project-context-service.js';
+import { readProjectMemories } from '../../services/memory/project-memory-service.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-function defined(obj) {
-    const result = {};
-    for (const [k, v] of Object.entries(obj)) {
-        if (v !== undefined)
-            result[k] = v;
-    }
-    return result;
-}
 export function registerProjectCommands(program, io) {
     const project = program.command('project').description('Aggregate Peaks state for a target project (read-only)');
     addJsonOption(project
@@ -75,104 +68,33 @@ export function registerProjectCommands(program, io) {
             process.exitCode = 1;
         }
     });
-    // --- Ontology commands (structured project memory for LLM consumption) ---
-    const ontology = project.command('ontology').description('Query structured project memory (modules, decisions, conventions)');
-    addJsonOption(ontology
-        .command('show')
-        .description('Read the full ontology JSON for LLM consumption')
-        .requiredOption('--project <path>', 'target project root')).action((options) => {
-        try {
-            const onto = loadOntology(options.project);
-            if (onto === null) {
-                // Auto-generate if missing
-                const result = generateProjectContext(options.project);
-                printResult(io, ok('project.ontology', result.ontology), options.json);
-                return;
-            }
-            printResult(io, ok('project.ontology', onto), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('project.ontology', 'ONTOLOGY_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(ontology
-        .command('module')
-        .description('Record or query a project module')
-        .requiredOption('--project <path>', 'target project root')
-        .option('--id <id>', 'module id (kebab-case)')
-        .option('--path <path>', 'file path for the module')
-        .option('--risk <level>', 'risk level: low, medium, high')
-        .option('--summary <text>', 'brief module description')
-        .option('--session <id>', 'session id')
-        .option('--put', 'write/update the module entry')).action((options) => {
-        try {
-            if (options.put) {
-                if (!options.id || !options.path || !options.session) {
-                    printResult(io, fail('project.ontology.module', 'MISSING_FIELDS', '--id, --path, --session required with --put', {}, ['Provide all required fields']), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                const risk = (options.risk === 'low' || options.risk === 'medium' || options.risk === 'high') ? options.risk : undefined;
-                const result = upsertModule(options.project, defined({
-                    id: options.id,
-                    path: options.path,
-                    session: options.session,
-                    risk,
-                    summary: options.summary
-                }));
-                printResult(io, ok('project.ontology.module', { modules: result.modules }), options.json);
-                return;
-            }
-            const onto = loadOntology(options.project) ?? generateProjectContext(options.project).ontology;
-            if (options.id) {
-                const mod = onto.modules.find((m) => m.id === options.id);
-                printResult(io, ok('project.ontology.module', mod ?? { notFound: true, id: options.id }), options.json);
-                return;
-            }
-            printResult(io, ok('project.ontology.module', { modules: onto.modules }), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('project.ontology.module', 'ONTOLOGY_MODULE_FAILED', getErrorMessage(error), {}, []), options.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(ontology
-        .command('decision')
-        .description('Record or query architectural decisions')
+    // --- Structured project memory (durable, LLM-authored, stored under .peaks/memory) ---
+    addJsonOption(project
+        .command('memories')
+        .description('Read durable project memories (decisions, conventions, modules, rules) from .peaks/memory for LLM consumption')
         .requiredOption('--project <path>', 'target project root')
-        .option('--id <id>', 'decision id')
-        .option('--what <text>', 'what was decided')
-        .option('--why <text>', 'rationale behind the decision')
-        .option('--scope <modules>', 'comma-separated module ids')
-        .option('--session <id>', 'session id')
-        .option('--date <date>', 'decision date')
-        .option('--put', 'write/update the decision')).action((options) => {
+        .option('--kind <kind>', 'filter by kind: project, rule, decision, reference, feedback, convention, module')).action((options) => {
         try {
-            if (options.put) {
-                if (!options.id || !options.what || !options.session || !options.date) {
-                    printResult(io, fail('project.ontology.decision', 'MISSING_FIELDS', '--id, --what, --session, --date required with --put', {}, []), options.json);
-                    process.exitCode = 1;
-                    return;
-                }
-                const result = upsertDecision(options.project, defined({
-                    id: options.id, what: options.what, why: options.why,
-                    scope: options.scope ? options.scope.split(',').map((s) => s.trim()).filter(Boolean) : [],
-                    session: options.session, date: options.date
-                }));
-                printResult(io, ok('project.ontology.decision', { decisions: result.decisions }), options.json);
+            const result = readProjectMemories(options.project);
+            if (options.kind) {
+                const memories = result.memories.filter((memory) => memory.kind === options.kind);
+                printResult(io, ok('project.memories', {
+                    memoryDir: result.memoryDir,
+                    kind: options.kind,
+                    total: memories.length,
+                    memories
+                }), options.json);
                 return;
             }
-            const onto = loadOntology(options.project) ?? generateProjectContext(options.project).ontology;
-            if (options.id) {
-                const dec = onto.decisions.find((d) => d.id === options.id);
-                printResult(io, ok('project.ontology.decision', dec ?? { notFound: true, id: options.id }), options.json);
-                return;
-            }
-            printResult(io, ok('project.ontology.decision', { decisions: onto.decisions }), options.json);
+            printResult(io, ok('project.memories', {
+                memoryDir: result.memoryDir,
+                total: result.total,
+                byKind: result.byKind,
+                memories: result.memories
+            }), options.json);
         }
         catch (error) {
-            printResult(io, fail('project.ontology.decision', 'ONTOLOGY_DECISION_FAILED', getErrorMessage(error), {}, []), options.json);
+            printResult(io, fail('project.memories', 'PROJECT_MEMORIES_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path and .peaks/memory directory']), options.json);
             process.exitCode = 1;
         }
     });

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

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

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

@@ -0,0 +1,111 @@
+import { fail, ok } from '../../shared/result.js';
+import { addJsonOption, printResult, getErrorMessage } from '../cli-helpers.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { buildStatusLineModel, parseStatusLineStdin } from '../../services/skills/skill-statusline-service.js';
+import { renderStatusLine } from '../../services/skills/skill-statusline-renderer.js';
+import { applyStatusLineInstall, planStatusLineInstall, removeStatusLineInstall } from '../../services/skills/statusline-settings-service.js';
+const STDIN_READ_TIMEOUT_MS = 250;
+/** Read piped stdin if present; resolve quickly with '' when attached to a TTY. */
+function readStdin() {
+    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();
+        });
+    });
+}
+function resolveScope(options) {
+    return options.global ? 'global' : 'project';
+}
+export function registerStatusLineCommands(program, io) {
+    const statusline = program
+        .command('statusline')
+        .description('Render the Peaks skill status line for Claude Code (reads session JSON on stdin)')
+        .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
+        .action(async (options) => {
+        const raw = await readStdin();
+        const stdin = parseStatusLineStdin(raw);
+        // When a project override is passed (or no stdin), seed cwd so detection works.
+        const seeded = options.project
+            ? { ...(stdin ?? {}), workspace: { current_dir: options.project } }
+            : stdin;
+        const model = buildStatusLineModel(seeded, Date.now());
+        io.stdout(renderStatusLine(model));
+    });
+    addJsonOption(statusline
+        .command('install')
+        .description('Install the Peaks status line into .claude/settings.json (project scope by default)')
+        .option('--global', 'install into the user-level ~/.claude/settings.json instead of the project')
+        .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
+        .option('--force', 'overwrite an existing non-Peaks statusLine entry')
+        .option('--dry-run', 'show what would change without writing')).action((options) => {
+        const scope = resolveScope(options);
+        const projectRoot = scope === 'project'
+            ? (options.project ?? findProjectRoot(process.cwd()) ?? process.cwd())
+            : undefined;
+        try {
+            if (options.dryRun) {
+                const plan = planStatusLineInstall(scope, projectRoot);
+                const warnings = plan.conflict
+                    ? [`An existing statusLine command is set: ${plan.conflictCommand}. Rerun with --force to overwrite.`]
+                    : [];
+                printResult(io, ok('statusline.install', { ...plan, applied: false, dryRun: true }, warnings), options.json);
+                return;
+            }
+            const result = applyStatusLineInstall(scope, projectRoot, options.force ? { force: true } : {});
+            const warnings = result.conflict && !result.applied
+                ? [`An existing statusLine command is set: ${result.conflictCommand}. Rerun with --force to overwrite.`]
+                : [];
+            const nextActions = result.applied
+                ? ['Restart Claude Code (or reload the window) so the status line takes effect']
+                : [];
+            printResult(io, ok('statusline.install', { ...result, dryRun: false }, warnings, nextActions), options.json);
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            printResult(io, fail('statusline.install', 'STATUSLINE_INSTALL_FAILED', message, { scope, applied: false }, [message]), options.json);
+            process.exitCode = 1;
+        }
+    });
+    addJsonOption(statusline
+        .command('uninstall')
+        .description('Remove the Peaks status line from .claude/settings.json')
+        .option('--global', 'remove from the user-level ~/.claude/settings.json instead of the project')
+        .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')).action((options) => {
+        const scope = resolveScope(options);
+        const projectRoot = scope === 'project'
+            ? (options.project ?? findProjectRoot(process.cwd()) ?? process.cwd())
+            : undefined;
+        try {
+            const result = removeStatusLineInstall(scope, projectRoot);
+            printResult(io, ok('statusline.uninstall', result), options.json);
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            printResult(io, fail('statusline.uninstall', 'STATUSLINE_UNINSTALL_FAILED', message, { scope, removed: false }, [message]), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/cli/program.js

@@ -10,6 +10,7 @@ import { registerProjectCommands } from './commands/project-commands.js';
 import { registerRequestCommands } from './commands/request-commands.js';
 import { registerScanCommands } from './commands/scan-commands.js';
 import { registerShadcnCommands } from './commands/shadcn-commands.js';
+import { registerStatusLineCommands } from './commands/statusline-commands.js';
 import { registerUnderstandCommands } from './commands/understand-commands.js';
 import { registerWorkspaceCommands } from './commands/workspace-commands.js';
 export { printResult } from './cli-helpers.js';
@@ -40,6 +41,7 @@ export function createProgram(io = { stdout: (text) => console.log(text), stderr
     registerRequestCommands(program, io);
     registerScanCommands(program, io);
     registerShadcnCommands(program, io);
+    registerStatusLineCommands(program, io);
     registerUnderstandCommands(program, io);
     registerWorkspaceCommands(program, io);
     return program;

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

@@ -24,5 +24,6 @@ export type DoctorOptions = {
     codegraphProbe?: () => CodegraphCapabilityProbe;
     skillPresenceProbe?: () => SkillPresence | null;
     skillPresenceFreshnessThresholdMs?: number;
+    statusLineInstalledProbe?: () => boolean;
 };
 export declare function runDoctor(options?: DoctorOptions): Promise<DoctorReport>;

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

@@ -8,6 +8,8 @@ import { requiredSchemaFiles, requiredSkillNames, schemasDir } from '../../share
 import { getErrorMessage } from '../../shared/result.js';
 import { loadSkillRegistry } from '../skills/skill-registry.js';
 import { getSkillPresence } from '../skills/skill-presence-service.js';
+import { planStatusLineInstall } from '../skills/statusline-settings-service.js';
+import { findProjectRoot } from '../config/config-safety.js';
 const CODEGRAPH_EXPECTED_VERSION = '0.7.10';
 const SKILL_PRESENCE_FRESHNESS_THRESHOLD_MS = 24 * 60 * 60 * 1000;
 function defaultCodegraphProbe() {
@@ -22,6 +24,17 @@ function defaultCodegraphProbe() {
         binaryExists: existsSync(binaryPath)
     };
 }
+function defaultStatusLineInstalledProbe() {
+    const projectRoot = findProjectRoot(process.cwd());
+    if (projectRoot === null)
+        return false;
+    try {
+        return planStatusLineInstall('project', projectRoot).alreadyInstalled;
+    }
+    catch {
+        return false;
+    }
+}
 const DESTRUCTIVE_APPLY_PATTERNS = [
     /peaks\s+memory\s+sync[^\n]*--apply/,
     /peaks\s+memory\s+extract[^\n]*--apply/,
@@ -190,6 +203,33 @@ export async function runDoctor(options = {}) {
             }
         }
     }
+    // Discoverability nudge: when a skill is actively orchestrating but the
+    // out-of-band statusLine isn't installed, the user has no terminal-level
+    // signal that Peaks is in control. Suggest installing it (non-failing).
+    const statusLineProbe = options.statusLineInstalledProbe ?? defaultStatusLineInstalledProbe;
+    let statusLineInstalled = false;
+    try {
+        statusLineInstalled = statusLineProbe();
+    }
+    catch {
+        statusLineInstalled = false;
+    }
+    if (presence !== null && !statusLineInstalled) {
+        checks.push({
+            id: 'statusline:install',
+            ok: true,
+            message: 'A Peaks skill is active but the statusLine is not installed; run `peaks statusline install` so the active skill shows in the terminal status bar'
+        });
+    }
+    else {
+        checks.push({
+            id: 'statusline:install',
+            ok: true,
+            message: statusLineInstalled
+                ? 'Peaks statusLine is installed'
+                : 'Peaks statusLine not installed (no active skill; install optional)'
+        });
+    }
     const probe = options.codegraphProbe ?? defaultCodegraphProbe;
     try {
         const result = probe();

package/dist/src/services/memory/project-context-service.d.ts

@@ -2,48 +2,10 @@ export type ProjectContextSection = {
     heading: string;
     body: string;
 };
-export type Module = {
-    id: string;
-    path: string;
-    risk?: 'low' | 'medium' | 'high';
-    sessions: string[];
-    summary?: string;
-};
-export type Decision = {
-    id: string;
-    what: string;
-    why?: string;
-    scope: string[];
-    session: string;
-    date: string;
-};
-export type Convention = {
-    id: string;
-    rule: string;
-    category: 'code-style' | 'architecture' | 'naming' | 'tooling' | 'other';
-    source: string;
-    date: string;
-};
-export type Ontology = {
-    version: 1;
-    updated: string;
-    project: string;
-    modules: Module[];
-    decisions: Decision[];
-    conventions: Convention[];
-};
-export declare function loadOntology(projectRoot: string): Ontology | null;
-export declare function saveOntology(projectRoot: string, onto: Ontology): void;
-export declare function upsertModule(projectRoot: string, mod: Omit<Module, 'sessions'> & {
-    session: string;
-}): Ontology;
-export declare function upsertDecision(projectRoot: string, dec: Decision): Ontology;
-export declare function upsertConvention(projectRoot: string, conv: Convention): Ontology;
 export declare function generateProjectContext(projectRoot: string): {
     path: string;
     content: string;
     sessionCount: number;
-    ontology: Ontology;
 };
 export declare function readProjectContext(projectRoot: string): string | null;
 export declare function getProjectContextPath(projectRoot: string): string;