talos-code 0.0.1 → 0.1.0

package/dist/commands/services-cli.js

@@ -0,0 +1,248 @@
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { assertNoUnknownOptions, takeOption, writeValue } from "./context.js";
+import { importTalosModule } from "../runtime/repo.js";
+import { createMemoryFacade } from "../services/memory-facade.js";
+import { createNotesFacade } from "../services/notes-facade.js";
+import { createTaskBoardFacade } from "../services/task-board-facade.js";
+import { createLibraryFacade } from "../services/library-facade.js";
+import { createForgeFacade } from "../services/forge-facade.js";
+const clean = (v) => { if (Array.isArray(v))
+    return v.map(clean); if (v && typeof v === 'object') {
+    const o = {};
+    for (const [k, x] of Object.entries(v)) {
+        if (/percorso|path/iu.test(k))
+            continue;
+        o[k] = clean(x);
+    }
+    return o;
+} return v; };
+function req(args, what) { const v = args.shift(); if (!v)
+    throw new Error(`${what}_REQUIRED`); return v; }
+export async function runNotesCommand(ctx, args0) { const a = [...args0], op = a.shift() ?? 'list'; const notes = createNotesFacade({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot }); let r; if (op === 'list') {
+    assertNoUnknownOptions(a);
+    const x = await notes.list();
+    r = x.state === 'ready' ? x.legacyRows : x;
+}
+else if (op === 'add') {
+    const title = req(a, 'TITLE'), body = req(a, 'BODY');
+    assertNoUnknownOptions(a);
+    r = (await notes.add({ title, content: body })).legacy;
+}
+else if (op === 'update') {
+    const id = req(a, 'ID');
+    const title = takeOption(a, '--title'), content = takeOption(a, '--body');
+    assertNoUnknownOptions(a);
+    r = (await notes.update(id, { ...(title !== undefined ? { title } : {}), ...(content !== undefined ? { content } : {}) })).legacy;
+}
+else if (op === 'delete') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await notes.delete(id)).legacy;
+}
+else if (op === 'link' || op === 'unlink') {
+    const noteId = req(a, 'NOTE_ID'), targetKind = req(a, 'TARGET_KIND'), targetId = req(a, 'TARGET_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'link' ? await notes.link(noteId, targetKind, targetId) : await notes.unlink(noteId, targetKind, targetId);
+}
+else
+    throw new Error(`Unsupported notes operation: ${op}`); writeValue(ctx, clean(r)); return 0; }
+export async function runTasksCommand(ctx, args0) { const a = [...args0], op = a.shift() ?? 'list'; const tasks = createTaskBoardFacade({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot }); let r; if (op === 'list') {
+    assertNoUnknownOptions(a);
+    const x = await tasks.list();
+    r = x.state === 'ready' ? x.legacyRows : x;
+}
+else if (op === 'add') {
+    const title = req(a, 'TITLE'), description = req(a, 'DESCRIPTION'), priority = (takeOption(a, '--priority') ?? 'normal');
+    assertNoUnknownOptions(a);
+    r = (await tasks.add({ title, description, priority })).legacy;
+}
+else if (op === 'update') {
+    const id = req(a, 'ID');
+    const title = takeOption(a, '--title'), description = takeOption(a, '--description'), priority = takeOption(a, '--priority');
+    assertNoUnknownOptions(a);
+    r = (await tasks.update(id, { ...(title !== undefined ? { title } : {}), ...(description !== undefined ? { description } : {}), ...(priority !== undefined ? { priority } : {}) })).legacy;
+}
+else if (op === 'complete') {
+    const id = req(a, 'ID'), status = (a.shift() ?? 'done');
+    assertNoUnknownOptions(a);
+    r = (await tasks.complete(id, status)).legacy;
+}
+else if (op === 'delete') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await tasks.delete(id)).legacy;
+}
+else if (op === 'depend' || op === 'undepend') {
+    const id = req(a, 'TASK_ID'), target = req(a, 'DEPENDENCY_TASK_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'depend' ? await tasks.depend(id, target) : await tasks.undepend(id, target);
+}
+else if (op === 'evidence' || op === 'unevidence') {
+    const id = req(a, 'TASK_ID'), sessionId = req(a, 'SESSION_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'evidence' ? await tasks.addEvidence(id, sessionId) : await tasks.removeEvidence(id, sessionId);
+}
+else if (op === 'assign' || op === 'unassign') {
+    const id = req(a, 'TASK_ID'), sessionId = req(a, 'AGENT_SESSION_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'assign' ? await tasks.assignAgent(id, sessionId) : await tasks.unassignAgent(id, sessionId);
+}
+else if (op === 'schedule' || op === 'unschedule') {
+    const id = req(a, 'TASK_ID'), automationId = req(a, 'AUTOMATION_ID');
+    assertNoUnknownOptions(a);
+    r = op === 'schedule' ? await tasks.attachSchedule(id, automationId) : await tasks.detachSchedule(id, automationId);
+}
+else
+    throw new Error(`Unsupported tasks operation: ${op}`); writeValue(ctx, clean(r)); return 0; }
+export async function runMemoryCommand(ctx, args0) { const a = [...args0], op = a.shift() ?? 'list'; const memory = createMemoryFacade({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot }); let r; if (op === 'list') {
+    assertNoUnknownOptions(a);
+    const x = await memory.list();
+    r = x.state === 'ready' ? x.legacyRows : x;
+}
+else if (op === 'search') {
+    const query = req(a, 'QUERY');
+    assertNoUnknownOptions(a);
+    const x = await memory.search(query);
+    r = x.state === 'ready' ? x.legacy : x;
+}
+else if (op === 'add') {
+    const title = req(a, 'TITLE'), content = req(a, 'CONTENT'), kind = (takeOption(a, '--kind') ?? 'preference');
+    assertNoUnknownOptions(a);
+    r = (await memory.add({ title, content, kind })).legacy;
+}
+else if (op === 'update') {
+    const id = req(a, 'ID'), title = takeOption(a, '--title'), content = takeOption(a, '--content'), kind = takeOption(a, '--kind');
+    assertNoUnknownOptions(a);
+    r = (await memory.update(id, { ...(title !== undefined ? { title } : {}), ...(content !== undefined ? { content } : {}), ...(kind !== undefined ? { kind } : {}) })).legacy;
+}
+else if (op === 'delete') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await memory.delete(id)).legacy;
+}
+else
+    throw new Error(`Unsupported memory operation: ${op}`); writeValue(ctx, clean(r)); return 0; }
+export async function runLibraryCommand(ctx, args0) { const a = [...args0], op = a.shift() ?? 'list'; const library = createLibraryFacade({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot }); let r; if (op === 'list') {
+    assertNoUnknownOptions(a);
+    const x = await library.list();
+    r = x.state === 'ready' ? x.legacyRows : x;
+}
+else if (op === 'search') {
+    const query = req(a, 'QUERY');
+    assertNoUnknownOptions(a);
+    r = (await library.search(query)).legacy;
+}
+else if (op === 'read') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await library.read(id)).legacy;
+}
+else if (op === 'preview') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = await library.preview(id);
+}
+else if (op === 'duplicates') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = await library.duplicates(id);
+}
+else if (op === 'context-ref') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = await library.prepareContextReference(id);
+}
+else if (op === 'import') {
+    const file = req(a, 'FILE');
+    assertNoUnknownOptions(a);
+    r = await library.importFile(file);
+}
+else if (op === 'export') {
+    const id = req(a, 'ID'), out = takeOption(a, '--out');
+    assertNoUnknownOptions(a);
+    if (!out)
+        throw new Error('LIBRARY_EXPORT_OUT_REQUIRED');
+    r = (await library.exportFile(id, out)).legacy;
+}
+else if (op === 'rename') {
+    const id = req(a, 'ID'), name = req(a, 'NAME');
+    assertNoUnknownOptions(a);
+    r = (await library.rename(id, name)).legacy;
+}
+else if (op === 'delete') {
+    const id = req(a, 'ID');
+    assertNoUnknownOptions(a);
+    r = (await library.delete(id)).legacy;
+}
+else
+    throw new Error(`Unsupported library operation: ${op}`); writeValue(ctx, clean(r)); return 0; }
+export async function runForgeCommand(ctx, args0) {
+    const a = [...args0], op = a.shift() ?? 'list', forgeRoot = join(ctx.paths.dataRoot, 'forge');
+    const base = createForgeFacade({ forgeRoot, repoRoot: ctx.repoRoot });
+    let r;
+    const packageFrom = async () => JSON.parse(await readFile(req(a, 'PACKAGE_FILE'), 'utf8'));
+    const owner = async (sessionId) => { const rc = await ctx.createRuntimeContext({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot, model: ctx.invocation.model ?? 'openai:gpt-5-mini', environmentKeys: 'consent' }); await rc.registry?.ripristina?.(); return createForgeFacade({ forgeRoot, repoRoot: ctx.repoRoot }, { registry: rc.registry }); };
+    if (op === 'list') {
+        assertNoUnknownOptions(a);
+        const x = await base.list();
+        r = x.state === 'ready' ? x.rows : x;
+    }
+    else if (op === 'inspect') {
+        const id = req(a, 'ID');
+        assertNoUnknownOptions(a);
+        r = await base.read(id);
+    }
+    else if (op === 'validate') {
+        const pkg = await packageFrom();
+        assertNoUnknownOptions(a);
+        r = base.validatePackage(pkg);
+    }
+    else if (op === 'scan') {
+        const pkg = await packageFrom();
+        assertNoUnknownOptions(a);
+        r = await base.scanPackage(pkg);
+    }
+    else if (op === 'simulate') {
+        const pkg = await packageFrom();
+        assertNoUnknownOptions(a);
+        r = await base.analyzePackage(pkg);
+    }
+    else if (op === 'install') {
+        const session = takeOption(a, '--session'), pkg = await packageFrom();
+        assertNoUnknownOptions(a);
+        if (!session)
+            throw new Error('FORGE_SESSION_REQUIRED');
+        r = await (await owner(session)).installPackage(session, pkg);
+    }
+    else if (op === 'versions') {
+        const id = req(a, 'ID'), session = takeOption(a, '--session');
+        assertNoUnknownOptions(a);
+        if (!session)
+            throw new Error('FORGE_SESSION_REQUIRED');
+        r = await (await owner(session)).versions(session, id);
+    }
+    else if (op === 'rollback') {
+        const id = req(a, 'ID'), revision = Number(req(a, 'REVISION')), session = takeOption(a, '--session');
+        assertNoUnknownOptions(a);
+        if (!Number.isSafeInteger(revision) || revision < 1)
+            throw new Error('FORGE_REVISION_INVALID');
+        if (!session)
+            throw new Error('FORGE_SESSION_REQUIRED');
+        r = await (await owner(session)).rollback(session, id, revision);
+    }
+    else if (op === 'enable' || op === 'disable') {
+        const id = req(a, 'ID'), session = takeOption(a, '--session');
+        assertNoUnknownOptions(a);
+        if (session)
+            r = await (await owner(session)).setEnabled(session, id, op === 'enable');
+        else {
+            const m = await importTalosModule(ctx.repoRoot, 'tool-forge-store.mjs');
+            r = await m.abilitaToolForgiato({ cartella: forgeRoot, id, abilitato: op === 'enable' });
+        }
+    }
+    else
+        throw new Error(`Unsupported forge operation: ${op}`);
+    writeValue(ctx, clean(r));
+    return 0;
+}

package/dist/commands/session-cli.js

@@ -0,0 +1,171 @@
+import { chmod, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { deleteSessionToolOutput } from "../runtime/output-store.js";
+import { exportMarkdown } from "../sessions/export-format.js";
+import { t } from "../i18n/index.js";
+import { secretValuesFromEnvironment } from "../diagnostics/redact.js";
+import { assertNoUnknownOptions, takeOption, writeValue } from "./context.js";
+import { importTalosModule } from "../runtime/repo.js";
+import { keyOriginForEntry, stateKeyOrigin } from "../provider/environment-keys.js";
+import { createSessionMetadataStore, sessionMetadataRoot } from "../sessions/metadata-store.js";
+import { buildSafeSessionShare, writeSafeSessionShare } from "../sessions/share.js";
+/* B1 slice 18: the entry decides. Resuming runs a model, so an environment key is used without asking and its origin is stated; reading sessions asks. */
+async function rc(ctx, environmentKeys) { const c = await ctx.createRuntimeContext({ projectRoot: ctx.projectRoot, paths: ctx.paths, repoRoot: ctx.repoRoot, model: ctx.invocation.model ?? 'openai:gpt-5-mini', environmentKeys }); if (typeof c.runtime?.restore === 'function')
+    await c.runtime.restore();
+else
+    await c.registry.ripristina?.(); return c; }
+async function sessionSummaries(c) { if (typeof c.runtime?.listSessions === 'function')
+    return c.runtime.listSessions(); const { normalizeSessionSummaries } = await import("../runtime/session-summary.js"); return normalizeSessionSummaries(c.registry.elenca?.() ?? []); }
+function metadataStore(ctx) { return createSessionMetadataStore({ rootDir: sessionMetadataRoot(ctx.paths.dataRoot) }); }
+async function summariesWithMetadata(ctx, c) { const store = metadataStore(ctx); const rows = await sessionSummaries(c); return Promise.all(rows.map(async (row) => { const metadata = await store.get(row.id ?? row.sessionId); return { ...row, ...(metadata?.name ? { name: metadata.name } : {}), tags: metadata?.tags ?? [], pinned: metadata?.pinned ?? false }; })); }
+function matchesSearch(row, query) { const q = query.trim().toLowerCase(); return [row.id, row.sessionId, row.name, row.project, ...(Array.isArray(row.tags) ? row.tags : [])].some(value => typeof value === 'string' && value.toLowerCase().includes(q)); }
+async function requireSession(c, id) { const row = (await sessionSummaries(c)).find((x) => x.id === id || x.sessionId === id); if (!row)
+    throw new Error('SESSION_NOT_FOUND'); return row; }
+/* R5b D1 (Q-R5-12): the Markdown export is sessions/export-format.ts, shared with the TUI's /export. */
+async function writeExport(out, format, payload) { await mkdir(dirname(resolve(out)), { recursive: true }); let body; if (format === 'json')
+    body = `${JSON.stringify(payload, null, 2)}\n`;
+else if (format === 'jsonl')
+    body = (payload.eventi ?? []).map((e) => JSON.stringify(e)).join('\n') + ((payload.eventi ?? []).length ? '\n' : '');
+else if (format === 'md')
+    body = exportMarkdown(payload, { secrets: secretValuesFromEnvironment(process.env) });
+else
+    throw new Error('SESSION_EXPORT_FORMAT_INVALID'); await writeFile(out, body, { encoding: 'utf8', mode: 0o600 }); try {
+    await chmod(resolve(out), 0o600);
+}
+catch (error) {
+    if (process.platform !== 'win32')
+        throw error;
+} }
+export async function runSessionCommand(ctx, args0) { const args = [...args0]; const op = args.shift() ?? 'list'; const c = await rc(ctx, op === 'resume' ? 'use' : 'consent'); const registry = c.registry; if (op === 'list') {
+    assertNoUnknownOptions(args);
+    writeValue(ctx, await summariesWithMetadata(ctx, c));
+    return 0;
+} if (op === 'search') {
+    const query = args.join(' ').trim();
+    if (!query)
+        throw new Error('SESSION_SEARCH_QUERY_REQUIRED');
+    writeValue(ctx, (await summariesWithMetadata(ctx, c)).filter((row) => matchesSearch(row, query)));
+    return 0;
+} const id = args.shift(); if (!id && op !== 'import')
+    throw new Error('SESSION_ID_REQUIRED'); if (op === 'tag' || op === 'untag' || op === 'pin' || op === 'unpin') {
+    await requireSession(c, id);
+    const store = metadataStore(ctx);
+    let metadata;
+    if (op === 'tag' || op === 'untag') {
+        const tag = args.join(' ');
+        if (!tag.trim())
+            throw new Error('SESSION_TAG_REQUIRED');
+        metadata = op === 'tag' ? await store.addTag(id, tag) : await store.removeTag(id, tag);
+    }
+    else {
+        assertNoUnknownOptions(args);
+        metadata = await store.setPinned(id, op === 'pin');
+    }
+    writeValue(ctx, { ok: true, sessionId: id, tags: metadata.tags, pinned: metadata.pinned });
+    return 0;
+} /* R5b D2 (Q-R5-12): the same name as the TUI's /rename; no name clears it. */ /* R5b D2 (Q-R5-12): the same name as the TUI's /rename; no name clears it. */ if (op === 'rename') {
+    await requireSession(c, id);
+    const name = args.join(' ').trim();
+    const metadata = await metadataStore(ctx).setName(id, name ? name : null);
+    writeValue(ctx, { ok: true, sessionId: id, name: metadata.name ?? null }, `${metadata.name ? t('screen.session.renamedCli', { id: String(id), name: metadata.name }) : t('screen.session.nameClearedCli', { id: String(id) })}\n`);
+    return 0;
+} if (op === 'context') {
+    assertNoUnknownOptions(args);
+    await requireSession(c, id);
+    if (typeof c.runtime?.contextStatus !== 'function')
+        throw new Error('SESSION_CONTEXT_UNAVAILABLE');
+    writeValue(ctx, await c.runtime.contextStatus(id));
+    return 0;
+} if (op === 'show') {
+    assertNoUnknownOptions(args);
+    const row = (await summariesWithMetadata(ctx, c)).find((x) => x.id === id || x.sessionId === id);
+    if (!row)
+        throw new Error('SESSION_NOT_FOUND');
+    const payload = registry.esporta?.(id);
+    writeValue(ctx, { ...row, eventCount: payload?.eventi?.length ?? 0 });
+    return 0;
+} if (op === 'fork') {
+    assertNoUnknownOptions(args);
+    const x = registry.forka(id);
+    if (x?.erroreAvvio)
+        throw Object.assign(new Error(x.erroreAvvio), { code: x.code });
+    writeValue(ctx, { sessionId: x.sessionId, forkedFrom: id }, `${x.sessionId}\n`);
+    return 0;
+} if (op === 'resume') {
+    const prompt = args.length ? args.join(' ') : undefined;
+    const sessionModel = (await sessionSummaries(c)).find((x) => x.id === id || x.sessionId === id)?.model;
+    const origin = prompt?.trim() ? stateKeyOrigin(ctx.io, ctx.invocation.outputFormat, keyOriginForEntry(c.runtime, typeof sessionModel === 'string' && sessionModel ? sessionModel : ctx.invocation.model ?? 'openai:gpt-5-mini', { refuseMissing: true })) : {};
+    const sid = await c.runtime.resume(id, prompt);
+    writeValue(ctx, { sessionId: sid, resumed: true, ...origin }, `${sid}\n`);
+    return 0;
+} if (op === 'share') {
+    const out = takeOption(args, '--out');
+    assertNoUnknownOptions(args);
+    if (!out)
+        throw new Error('SESSION_SHARE_OUT_REQUIRED');
+    const row = await requireSession(c, id);
+    const payload = registry.esporta?.(id);
+    if (!payload)
+        throw new Error('SESSION_NOT_FOUND');
+    const store = metadataStore(ctx);
+    const metadata = await store.get(id);
+    const share = buildSafeSessionShare({ summary: row, metadata, payload, secrets: secretValuesFromEnvironment(process.env) });
+    await writeSafeSessionShare(out, share);
+    writeValue(ctx, { ok: true, sessionId: id, schema: share.schema, redacted: true, out: resolve(out) }, `Shared redacted ${id} to ${out}\n`);
+    return 0;
+} if (op === 'export') {
+    const format = takeOption(args, '--format') ?? 'json';
+    const out = takeOption(args, '--out');
+    assertNoUnknownOptions(args);
+    if (!out)
+        throw new Error('SESSION_EXPORT_OUT_REQUIRED');
+    const payload = registry.esporta?.(id);
+    if (!payload)
+        throw new Error('SESSION_NOT_FOUND');
+    await writeExport(out, format, payload);
+    writeValue(ctx, { ok: true, sessionId: id, format, out: resolve(out) }, `Exported ${id} to ${out}\n`);
+    return 0;
+} if (op === 'delete') {
+    assertNoUnknownOptions(args);
+    const sm = await importTalosModule(ctx.repoRoot, 'session-store.mjs');
+    await sm.eliminaSessionePersistita({ cartellaStore: ctx.paths.sessionsRoot, sessionId: id }); /* R5a E6 (Q-R5-10): the session's kept command outputs go with it. */
+    await deleteSessionToolOutput(ctx.paths.dataRoot, String(id));
+    writeValue(ctx, { ok: true, sessionId: id }, `Deleted ${id}\n`);
+    return 0;
+} if (op === 'import') {
+    const file = id ?? args.shift();
+    if (!file)
+        throw new Error('SESSION_IMPORT_FILE_REQUIRED');
+    assertNoUnknownOptions(args);
+    let info;
+    try {
+        info = await stat(file);
+    }
+    catch {
+        throw new Error('SESSION_IMPORT_INVALID');
+    }
+    if (!info.isFile() || info.size > 256 * 1024 * 1024)
+        throw new Error('SESSION_IMPORT_INVALID');
+    let data;
+    try {
+        data = JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        throw new Error('SESSION_IMPORT_INVALID');
+    }
+    const sourceSchema = data?.schema ?? data?.header?.schema;
+    if (sourceSchema !== 'talos.harness-ui.session-export.v1' && sourceSchema !== 'talos.cli.session.v1')
+        throw new Error('SESSION_SCHEMA_UNSUPPORTED');
+    const rawEvents = data.eventi ?? data.events ?? [];
+    if (!Array.isArray(rawEvents))
+        throw new Error('SESSION_IMPORT_INVALID');
+    const safeEvents = rawEvents.filter((e) => e && typeof e === 'object' && e.type !== 'ApprovalRequested');
+    const importId = String(data.sessionId ?? data.header?.sessionId ?? 'imported');
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(importId) || importId.includes('..'))
+        throw new Error('SESSION_IMPORT_ID_INVALID');
+    const target = join(ctx.paths.dataRoot, 'imports', `${importId}.json`);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, `${JSON.stringify({ ...data, eventi: safeEvents, events: undefined, sourceSchema, importedBy: 'talos-cli', importedAt: new Date().toISOString() }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    writeValue(ctx, { ok: true, sessionId: importId, file: target, pendingApprovalsDropped: rawEvents.length - safeEvents.length, runnable: false }, `Imported archive ${importId}\n`);
+    return 0;
+} throw new Error(`Unsupported session operation: ${op}`); }