@prodero/curator 0.1.0 → 0.2.0

package/dist/status-presentation.js

@@ -0,0 +1,20 @@
+import { publicDiagnostic } from './core/diagnostics.js';
+import { PRODERO_VERSION } from './core/constants.js';
+import { MEMORY_COPY } from './memory-presentation.js';
+const plain = (value) => value.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ').trim();
+export function statusFailure(error, scope, migration) {
+    const message = plain(publicDiagnostic(error)), code = /^(PRODERO_[A-Z0-9_]+):/.exec(message)?.[1] ?? 'PRODERO_STATUS_FAILED';
+    return { ok: false, version: PRODERO_VERSION, scope, error: { code, message, recovery: migration ? plain(publicDiagnostic(migration.recovery ?? (migration.state === 'runtime-too-old' ? 'Update Curator before reading this project.' : 'Run prodero migrate status with this project root to review the required update.'))) : 'Check the command arguments, selected root, and preserved configuration before retrying.' }, ...(migration ? { migration: { ...migration, ...(migration.diagnostic ? { diagnostic: plain(publicDiagnostic(migration.diagnostic)) } : {}), ...(migration.recovery ? { recovery: plain(publicDiagnostic(migration.recovery)) } : {}) } } : {}) };
+}
+export function renderStatusFailure(result) {
+    return [`Prodero ${result.version} · ${result.scope} status unavailable`, `${result.error.code}: ${result.error.message}`, result.error.recovery, ...(result.migration ? [`Project update: ${result.migration.state}`] : [])].join('\n');
+}
+const yes = (value) => value === null ? 'unknown' : value ? 'yes' : 'no';
+export function renderMachineStatus(result) {
+    return [`Prodero ${result.version}`, `Machine integrations${result.ok ? '' : ' · attention required'}`, ...result.hosts.flatMap(h => [`${h.name}: ${h.state.replaceAll('-', ' ')}`, `  Detected: ${yes(h.detected)} · MCP configured: ${yes(h.mcpConfigured)} · Launcher installed: ${yes(h.launcherInstalled)}${h.runtimeMode ? ` · Runtime: ${h.runtimeMode}` : ''}`, `  ${plain(publicDiagnostic(h.message))}`])].join('\n');
+}
+export function renderProjectStatus(result) {
+    const p = result.project, u = result.update;
+    return [`Prodero ${result.version}`, `Project: ${plain(p.name)} (${plain(p.root)})`, `Initialized: ${yes(p.initialized)} · Git repository: ${yes(p.git)} · Project instructions: ${yes(p.agentsFile)}`, ...(p.initialized ? [`Project schema: ${p.schemaVersion}`, `Knowledge: ${p.knowledgeCount} current · ${p.localKnowledgeCount} Local · ${p.versionedKnowledgeCount} Versioned`, `Sessions: ${p.sessionCount} total · ${p.activeSessionCount} active · ${p.pendingSessionCount} pending`, `Skills: ${p.skillCount} active · ${p.skillCandidateCount} candidates`, `Checkpoints: ${p.checkpointCount} · Last sync: ${p.lastSyncAt ?? 'never'}`, `Needs attention: ${p.conflictCount} conflicts · ${p.knowledgeGraph.brokenReferences} broken references · ${p.promotionRecommendedCount} sharing suggestions`].concat(p.memoryHealth?.missingProvenanceItems ? [`Provenance: ${p.memoryHealth.missingProvenanceItems} current records with incomplete metadata. ${MEMORY_COPY.incompleteProvenance}`] : []) : ['Project is not initialized. Run prodero init with --root set to this directory.']), u.status === 'current' ? `Update: current (${u.current})` : u.status === 'update-available' ? `Update available: ${u.current} → ${u.latest}` : `Update check ${u.status}: ${plain(publicDiagnostic(u.error ?? 'No release information is available.'))}`, ...(u.status === 'update-available' && u.manualUpdateCommand ? [u.manualUpdateCommand] : [])].join('\n');
+}
+//# sourceMappingURL=status-presentation.js.map

package/dist/text-layout.js

@@ -0,0 +1,278 @@
+import { numberedActions } from './conversation-presentation.js';
+const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+const graphemes = (s) => Array.from(segmenter.segment(s), x => x.segment);
+const glyphWidth = (s) => {
+    const n = s.codePointAt(0) ?? 0;
+    if (/^[\p{Mark}]+$/u.test(s))
+        return 0;
+    return /[\p{Extended_Pictographic}\p{Regional_Indicator}\u20e3]/u.test(s) || n >= 0x1100 && (n <= 0x115f || n >= 0x2e80 && n <= 0xa4cf || n >= 0xac00 && n <= 0xd7a3 || n >= 0xf900 && n <= 0xfaff || n >= 0xfe10 && n <= 0xfe6f || n >= 0xff01 && n <= 0xff60 || n >= 0x20000 && n <= 0x3ffff) ? 2 : 1;
+};
+export const textWidth = (s) => graphemes(s).reduce((n, g) => n + glyphWidth(g), 0);
+// Formatting never permits terminal escapes, bidi controls or injected fence endings.
+// Newlines and literal code/body spacing survive in the verbatim fallback below.
+export const safeText = (s) => String(s ?? '').replace(/\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~])/g, '').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, '');
+export function wrapText(raw, width) {
+    const result = [];
+    for (const paragraph of safeText(raw).replace(/\t/g, '    ').split(/\r?\n/)) {
+        let line = '', used = 0;
+        for (const g of graphemes(paragraph)) {
+            const size = glyphWidth(g);
+            if (used + size > width && line) {
+                const cut = line.lastIndexOf(' ');
+                if (cut > 0) {
+                    result.push(line.slice(0, cut));
+                    line = line.slice(cut + 1);
+                    used = textWidth(line);
+                }
+                else {
+                    result.push(line);
+                    line = '';
+                    used = 0;
+                }
+            }
+            line += g;
+            used += size;
+        }
+        result.push(line);
+    }
+    return result;
+}
+/** Dynamic fences retain complete Markdown/code examples without escaping their wording. */
+export function textFence(content) {
+    const text = safeText(content);
+    let longest = 2;
+    for (const m of text.matchAll(/`+/g))
+        longest = Math.max(longest, m[0].length);
+    const fence = '`'.repeat(longest + 1);
+    return `${fence}text\n${text}\n${fence}`;
+}
+export function entryKey(index) {
+    let n = index + 1, key = '';
+    do {
+        n--;
+        key = String.fromCharCode(65 + n % 26) + key;
+        n = Math.floor(n / 26);
+    } while (n);
+    return key;
+}
+const number = (n) => n.toLocaleString('en-US');
+export function budgetLines(b) {
+    if (!Number.isFinite(b.used) || !Number.isFinite(b.total) || b.used < 0 || b.total <= 0)
+        return ['Budget unavailable.'];
+    const percent = Math.round(b.used / b.total * 100);
+    const filled = Math.max(0, Math.min(25, Math.round(b.used / b.total * 25)));
+    return ['▰'.repeat(filled) + '▱'.repeat(25 - filled) + ` ${percent}%`, `${number(b.used)} / ${number(b.total)} est. tokens`, `${b.source} · Prodero allocation only.`, ...(b.used > b.total ? ['Allocation exceeds its budget.'] : [])];
+}
+export function renderProductText(vm, diagnostics = false, expanded = diagnostics, plain = false) {
+    const scene = vm.textScene, action = scene?.action, v = vm.conversation;
+    const width = 38, prefix = plain ? '| ' : '│ ', rule = plain ? '-' : '─';
+    const screens = { open: '01', status: '01', 'status-details': '01', initialized: '01', knowledge: '02', 'knowledge-mutated': '02', prepare: '03', context: '03', 'memory-sync': '04', 'curation-question': '04', curation: '05', 'instruction-review': '06', 'instruction-optimize': '06', 'promotion-preview': '07', 'promotion-applied': '07', 'session-close': '08', 'session-review': '08', 'config-get': '09', 'update-instructions': '10', migration: '10', error: '00' };
+    const screen = vm.knowledgeTable ? '02' : screens[action ?? ''] ?? '00';
+    const head = `${plain ? '+-' : '╭─'} >_ PRODERO `;
+    const lines = [head + rule.repeat(width - textWidth(head) - 4) + ` /${screen}`];
+    const line = (text = '') => {
+        const indent = (text.match(/^ +/)?.[0] ?? '').slice(0, 12);
+        lines.push(...wrapText(text.slice(indent.length), width - 2 - indent.length).map(s => prefix.trimEnd() + (s.trimEnd() ? ' ' + indent + s.trimEnd() : '')));
+    };
+    const section = (title) => {
+        if (textWidth(safeText(title)) > width - 5) {
+            lines.push((plain ? '+' : '├') + rule.repeat(width - 1));
+            line(title);
+            return;
+        }
+        const parts = wrapText(title, width - 5);
+        const p = `${plain ? '+-' : '├─'} ${parts.shift()} `;
+        lines.push(p + rule.repeat(Math.max(0, width - textWidth(p))));
+        parts.forEach(part => line(part));
+    };
+    const inset = () => { line(); lines.push(prefix + '  ' + rule.repeat(27)); line(); };
+    const title = vm.title.replace(/^Prodero · /, '');
+    line(action === 'update-instructions' ? 'Prodero · terminal update' : scene?.project ? `${scene.project} · project memory` : 'Prodero');
+    line();
+    const prepared = action === 'prepare' || action === 'context';
+    const full = expanded || !v || v.kind === 'details';
+    const compactReady = prepared && !full && !v?.blocking && !v?.attention.length;
+    if (compactReady) {
+        const compact = ['>_ PRODERO /03 · Context Ready'];
+        if (scene?.project)
+            compact.push(...wrapText(scene.project, width));
+        compact.push(...wrapText(v?.facts.find(x => x.includes(' required · ')) ?? '', width));
+        if (scene?.budget)
+            compact.push(...wrapText(`${number(scene.budget.used)} / ${number(scene.budget.total)} est. Prodero tokens`, width));
+        compact.push('Ready · continuing the task');
+        return textFence(compact.join('\n'));
+    }
+    // Exact bodies are deliberately unframed: long code/paths and whitespace are not
+    // truncated or rewritten merely to fit a phone. The panel remains bounded.
+    const bodies = [];
+    const verbatim = (heading, items) => {
+        if (!items.length)
+            return;
+        bodies.push(`${heading}:\n` + items.map(i => [i.title, i.body, ...i.notes].filter(Boolean).join('\n')).join('\n\n   ' + rule.repeat(27) + '\n\n'));
+    };
+    if (scene?.home && !full) {
+        const h = scene.home;
+        if (h.initialized) {
+            if (action === 'initialized') {
+                line('Initialized');
+                line();
+            }
+            section('CONTEXT');
+            if (scene.budget)
+                budgetLines(scene.budget).forEach(x => line(plain ? x.replaceAll('▰', '#').replaceAll('▱', '.') : x));
+            else
+                line('Task allocation not prepared here.');
+            line();
+            section('MEMORY');
+            if (h.records !== undefined)
+                line(`${number(h.records)} records`);
+            if (h.local !== undefined && h.versioned !== undefined)
+                line(`${number(h.local)} local · ${number(h.versioned)} versioned`);
+            line();
+            section('ATTENTION');
+            if (h.deferred !== undefined)
+                line(`? ${h.deferred} deferred questions`);
+            if (h.pending !== undefined)
+                line(`Δ ${h.pending} unapplied change groups`);
+            (v?.attention ?? []).forEach(x => line(x));
+            if (!v?.attention.length && h.deferred === undefined && h.pending === undefined)
+                line(action === 'status' && h.records === undefined ? 'Lightweight status; counts not loaded.' : 'No attention needed.');
+            // Session activity is real data, not evidence of a background agent.
+            v?.facts.filter(x => x.startsWith('Session')).forEach(x => line(x));
+        }
+        else {
+            section(v?.state ?? title);
+            (v?.facts ?? vm.notices).forEach(x => line(x));
+            v?.attention.forEach(x => line(x));
+        }
+    }
+    else if (prepared) {
+        section(v?.blocking ? v.state : v?.attention.length ? 'Attention' : action === 'prepare' ? 'Context Ready' : 'View Context');
+        if (!compactReady && scene?.task)
+            line(`Task: ${scene.task}`);
+        if (!v?.blocking)
+            line(action === 'context' ? 'Read-only context view.' : v?.attention.length ? 'Task is not blocked; see attention.' : 'Ready · continuing the task');
+        const facts = v?.facts.filter(x => !x.startsWith('Context  ')) ?? [];
+        if (!compactReady) {
+            line();
+            section('PROVIDED TO AGENT');
+        }
+        facts.forEach(x => line(x));
+        if (scene?.budget) {
+            if (!compactReady) {
+                line();
+                section('PRODERO CONTEXT');
+                budgetLines(scene.budget).forEach(x => line(plain ? x.replaceAll('▰', '#').replaceAll('▱', '.') : x));
+            }
+            else
+                line(`${number(scene.budget.used)} / ${number(scene.budget.total)} est. Prodero tokens`);
+        }
+        if (v?.attention.length) {
+            line();
+            section('ATTENTION');
+            v.attention.forEach(x => line(x));
+        }
+        if (full)
+            for (const s of vm.sections) {
+                section(s.title);
+                s.items.forEach((i, index) => { if (index)
+                    inset(); line(i.title); });
+                verbatim(s.title, s.items);
+            }
+    }
+    else if (vm.knowledgeTable) {
+        const t = vm.knowledgeTable;
+        section('KNOWLEDGE');
+        line(t.rows.length ? `Showing ${t.offset + 1}-${t.offset + t.rows.length} of ${t.total}` : 'No knowledge matches these filters.');
+        t.rows.forEach((r, index) => {
+            if (index)
+                inset();
+            else
+                line();
+            line(`${r.key} · ${r.title}`);
+            line(`  ${r.layer}`);
+            const preview = vm.sections.find(s => s.title === 'Knowledge')?.items[index]?.body;
+            if (preview) {
+                const flat = safeText(preview).replace(/\s+/g, ' ').trim();
+                const summary = graphemes(flat).slice(0, 90).join('');
+                line('  ' + summary + (summary.length < flat.length ? '…' : ''));
+            }
+        });
+        if (t.rows.length) {
+            line();
+            line('Enter a letter to open its record.');
+        }
+        if (expanded)
+            verbatim('Knowledge', vm.sections.find(s => s.title === 'Knowledge')?.items ?? []);
+    }
+    else {
+        if (action === 'memory-sync') {
+            section('CURATE MEMORY');
+            const state = full ? title.replace(/^Curate Memory · /, '') : v?.state ?? title;
+            if (state !== 'Curate Memory')
+                line(state);
+        }
+        else
+            section(action === 'session-close' ? 'Session closed' : v?.kind !== 'details' && !full ? v?.state ?? title : title);
+        if (action === 'session-close')
+            line(v?.state ?? 'Check saved state');
+        if (full && v?.reviewRequired)
+            line('Review required · not approval.');
+        if (!full && v?.kind !== 'details') {
+            v?.facts.forEach(x => line(x));
+            if (v?.attention.length) {
+                line();
+                section('ATTENTION');
+                v.attention.forEach(x => line(x));
+            }
+        }
+        else {
+            vm.metrics.forEach(m => line(`${m.label}  ${m.value}${m.detail ? ' · ' + m.detail : ''}`));
+            if (!vm.sections.some(s => s.title === 'Knowledge detail'))
+                vm.notices.forEach(x => line(x));
+            for (const s of vm.sections) {
+                section(s.title);
+                s.items.forEach((i, n) => { if (n)
+                    inset(); line(i.title); });
+                verbatim(s.title, s.items);
+            }
+        }
+    }
+    // Exact reviews precede the approval menu; reading and approving remain distinct.
+    if (v?.prompt) {
+        line();
+        wrapText(v.prompt, width - 2).forEach(x => line(x));
+    }
+    lines.push((plain ? '+' : '╰') + rule.repeat(width - 1));
+    const actions = numberedActions(vm, full);
+    const menu = [];
+    if (actions.length) {
+        menu.push('', 'Available actions:', '');
+        for (const a of actions) {
+            const key = `  ${a.number} > `;
+            const parts = wrapText(a.label, width - key.length);
+            menu.push(key + parts[0], ...parts.slice(1).map(x => ' '.repeat(key.length) + x));
+            if (a.approval)
+                menu.push('      Explicit approval required.');
+            if (a.input)
+                menu.push(...wrapText(a.input.prompt, width - 6).map(x => '      ' + x));
+        }
+        menu.push('', 'Reply with a number or the command name.');
+    }
+    // Keep the service separator outside the record and its metadata.
+    if (vm.sections.some(s => s.title === 'Knowledge detail'))
+        bodies.push('-------------\n' + vm.notices.join('\n'));
+    if (diagnostics || action === 'curation' || full && action === 'migration')
+        for (const s of vm.diagnostics ?? [])
+            verbatim(s.title, s.items);
+    const panel = textFence(lines.join('\n'));
+    const exact = bodies.map(textFence);
+    const approval = full && actions.some(a => a.approval) && (action === 'memory-sync' || action === 'migration')
+        ? action === 'memory-sync' ? 'Approve these exact changes?' : `${actions.find(a => a.approval).label}?` : '';
+    return [panel, ...exact, menu.length ? textFence(menu.join('\n').replace(/^\n/, '').trimEnd()) : '', approval].filter(Boolean).join('\n\n');
+}
+/** Public sanitized errors have no executable retry/apply action. */
+export function renderTextError(message, plain = false) {
+    return renderProductText({ version: 1, title: 'Prodero · Error', metrics: [], notices: [message], sections: [], actions: [], textScene: { action: 'error' } }, false, true, plain);
+}
+//# sourceMappingURL=text-layout.js.map

package/dist/update-command.js

@@ -0,0 +1,53 @@
+import { createInterface } from 'node:readline/promises';
+import { runNpmUpdate, NpmUpdateError } from './core/npm-update.js';
+const help = `Usage: prodero update [exact-version] [--yes]
+
+Finish work and close Codex and Claude before updating. The terminal waits for
+npm and verifies the installed CLI; reopen your applications and reconnect afterward.
+Only an ordinary same-user global npm installation with Node 22.14–22.x/npm 10.9.x
+is supported. Install scripts are disabled; project and host settings are untouched.
+
+Without a version, an interactive terminal checks the latest public release.
+Non-interactive use requires an exact stable version and --yes, confirming that
+work has ended and applications are closed. Equal versions are a no-op; downgrades
+are refused. No sudo, automatic application closing or package rollback is used.`;
+/** Closing stdin or Ctrl-C at the maintenance prompt is a refusal. */
+export function terminalConfirmation(question, input = process.stdin, output = process.stdout) {
+    const terminal = createInterface({ input, output });
+    return new Promise(resolve => { let done = false; const finish = (answer) => { if (done)
+        return; done = true; terminal.close(); resolve(answer); }; terminal.once('close', () => finish(false)); terminal.once('SIGINT', () => finish(false)); terminal.question(question).then(answer => finish(/^y(?:es)?$/i.test(answer.trim())), () => finish(false)); });
+}
+export async function updateCommand(args, dependencies = {}) {
+    if (args.length === 1 && ['--help', '-h'].includes(args[0])) {
+        (dependencies.write ?? console.log)(help);
+        return 0;
+    }
+    let yes = false, targetVersion;
+    for (const arg of args) {
+        if (arg === '--yes') {
+            if (yes)
+                throw new NpmUpdateError('NPM_UPDATE_ARGUMENT', 'Specify --yes only once.');
+            yes = true;
+        }
+        else if (arg.startsWith('-') || targetVersion !== undefined)
+            throw new NpmUpdateError('NPM_UPDATE_ARGUMENT', 'Use prodero update [exact-version] [--yes].');
+        else
+            targetVersion = arg;
+    }
+    const write = dependencies.write ?? console.log;
+    const confirm = dependencies.confirm ?? terminalConfirmation;
+    try {
+        const result = await runNpmUpdate({ targetVersion, yes }, { ...dependencies, write, confirm, interactive: dependencies.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY) });
+        write(result.message);
+        return result.exitCode;
+    }
+    catch (error) {
+        if (error instanceof NpmUpdateError) {
+            write(`${error.code}: ${error.message}`);
+            return error.exitCode;
+        }
+        write('NPM_UPDATE_FAILED: Cannot complete or verify this update. Inspect this npm installation before retrying.');
+        return 1;
+    }
+}
+//# sourceMappingURL=update-command.js.map

package/dist/update-instructions.js

@@ -0,0 +1,4 @@
+/** Shared copy only: safe to bundle into the App; no execution or host access. */
+export const MANUAL_UPDATE_COMMAND = 'prodero update';
+export const UPDATE_INSTRUCTIONS = 'Finish the current work and close your MCP hosts. In a terminal, run prodero update and review its plan before approving installation. After the terminal reports completion, restart and reconnect your hosts. Open Prodero again and review any project knowledge migration separately. This chat action only shows instructions; it has not installed or staged a runtime, refreshed project integration, or changed your development runtime selection.';
+//# sourceMappingURL=update-instructions.js.map