talos-code 0.0.1 → 0.1.0

package/package.json

@@ -1,9 +1,67 @@
 {
   "name": "talos-code",
-  "version": "0.0.1",
-  "description": "TALOS CLI - official npm package name of the TALOS project.",
-  "homepage": "https://github.com/Ninozzz95/talos",
-  "repository": { "type": "git", "url": "git+https://github.com/Ninozzz95/talos.git" },
+  "version": "0.1.0",
+  "description": "TALOS in the terminal: a coding agent with per-tool permissions, file checkpoints and resumable sessions, on the model you choose.",
+  "keywords": [
+    "coding-agent",
+    "cli",
+    "terminal",
+    "llm",
+    "ai",
+    "agent"
+  ],
   "license": "AGPL-3.0-only",
-  "files": ["README.md"]
+  "type": "module",
+  "engines": {
+    "node": ">=24.18.0 <25"
+  },
+  "bin": {
+    "talos": "dist/main.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node scripts/run-tests.mjs \"test/**/*.test.ts\"",
+    "test:local": "node scripts/run-tests.mjs \"test/**/*.test.ts\"",
+    "test:tui": "node scripts/run-tests.mjs \"test/tui/**/*.test.ts\"",
+    "test:acceptance": "npm run build && node scripts/run-tests.mjs --test-concurrency=1 --test-timeout=300000 \"test/acceptance/**/*.scenario.ts\"",
+    "prepack": "node scripts/clean-dist.mjs && npm run build && node scripts/pack-vendor.mjs"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "4.0.49",
+    "@ai-sdk/google": "4.0.64",
+    "@ai-sdk/openai": "4.0.61",
+    "@microsoft/mxc-sdk": "0.8.0",
+    "@modelcontextprotocol/client": "2.0.0",
+    "@napi-rs/keyring": "1.3.0",
+    "ai": "7.0.93",
+    "diff": "9.0.0",
+    "docx": "9.5.1",
+    "eventsource-parser": "4.1.0",
+    "ink": "7.1.1",
+    "jszip": "3.10.1",
+    "pdf-lib": "1.17.1",
+    "pdfmake": "0.3.11",
+    "pptxgenjs": "4.0.1",
+    "react": "19.3.0",
+    "sqlite-vec": "0.1.9",
+    "string-width": "8.2.2",
+    "typescript": "5.9.2",
+    "unicode-segmenter": "0.15.0",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
+    "zod": "4.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.4",
+    "@types/react": "19.2.17",
+    "@xterm/headless": "6.0.0",
+    "node-pty": "1.2.0-beta.15"
+  },
+  "files": [
+    "dist/",
+    "vendor/",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ]
 }

package/vendor/context-engine/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@talos/context-engine",
+  "license": "AGPL-3.0-only",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": { ".": "./src/engine.mjs", "./contracts": "./src/contracts.mjs", "./sqlite": "./src/node/sqlite-store.mjs", "./retrieval": "./src/retrieval.mjs" },
+  "scripts": { "test": "node --test" },
+  "engines": { "node": ">=24.18.0 <27" },
+  "dependencies": { "zod": "4.5.4", "sqlite-vec": "0.1.9" }
+}

package/vendor/context-engine/src/compaction-planner.mjs

@@ -0,0 +1,57 @@
+import { ContextEngineError, parseContextSettings } from './contracts.mjs';
+import { validateContextProfile } from './profiles.mjs';
+
+export function computeContextBudget(options) {
+  const profile = validateContextProfile(options);
+  const settings = parseContextSettings(options.settings ?? {});
+  const inputLimit = profile.windowTokens - profile.responseReserve - profile.safetyMarginTokens;
+  const inputTokens = options.inputTokens ?? 0;
+  if (!Number.isInteger(inputTokens) || inputTokens < 0) throw new ContextEngineError('Conteggio del contesto non valido.', 'CTX_INVALID_PROFILE');
+  return { ...profile, inputLimit, inputTokens, headroom: inputLimit - inputTokens, targetTokens: Math.floor(inputLimit * settings.targetRatio), triggerTokens: Math.floor(inputLimit * settings.triggerRatio), fits: inputTokens <= inputLimit, shouldPrepare: inputTokens >= inputLimit * settings.triggerRatio };
+}
+
+export function selectClosedPrefix(records, { retainRecentTurns = 2, force = false } = {}) {
+  const userIndices = records.flatMap((record, index) => record.message.role === 'user' ? [index] : []);
+  const desired = userIndices.length > retainRecentTurns ? userIndices[userIndices.length - retainRecentTurns] ?? records.length : 0;
+  const pending = new Set();
+  const boundaries = [];
+  let hasConversation = false;
+  for (let index = 0; index < records.length; index++) {
+    const message = records[index].message;
+    if (!['system', 'developer'].includes(message.role)) hasConversation = true;
+    for (const call of message.tool_calls ?? []) pending.add(call.id);
+    if (message.role === 'tool') pending.delete(message.tool_call_id);
+    if (pending.size === 0 && hasConversation) boundaries.push(index + 1);
+  }
+  let cut = boundaries.filter(value => value <= desired).at(-1) ?? 0;
+  // A manual request may retain fewer turns, but never half of the latest exchange.
+  if (!cut && force) cut = boundaries.filter(value => value <= (userIndices.at(-1) ?? 0)).at(-1) ?? 0;
+  return { prefix: records.slice(0, cut), tail: records.slice(cut), pendingCalls: [...pending], coveredThrough: records[cut - 1]?.sequence ?? 0 };
+}
+
+export function planCompaction(records, options) {
+  const selection = selectClosedPrefix(records, options);
+  const budget = computeContextBudget(options);
+  // Segment size is a conservative planning estimate, checked by the real counter before inference.
+  const maxSegmentChars = Math.max(256, Math.floor((budget.inputLimit - 1024) * 2));
+  const segments = [];
+  let text = ''; let sourceIds = [];
+  const flush = () => { if (text) segments.push({ id: `segment-${segments.length}`, text, sourceIds: [...new Set(sourceIds)] }); text = ''; sourceIds = []; };
+  for (const record of selection.prefix) {
+    if (['system', 'developer'].includes(record.message.role)) continue;
+    const content = record.message.content;
+    const plain = typeof content === 'string' ? content : Array.isArray(content) ? content.filter(p => ['text', 'input_text', 'output_text'].includes(p?.type) && typeof p.text === 'string').map(p => p.text).join('\n') : '';
+    const body = `${record.id} (${record.message.role})\n${plain}${record.message.tool_calls?.length ? '\nTool calls: ' + JSON.stringify(record.message.tool_calls) : ''}\n`;
+    let offset = 0;
+    while (offset < body.length) {
+      const remaining = maxSegmentChars - text.length;
+      let length = Math.min(remaining, body.length - offset);
+      if (length > 1 && /[\uD800-\uDBFF]/u.test(body[offset + length - 1])) length--;
+      if (!length) { flush(); continue; }
+      text += body.slice(offset, offset + length); sourceIds.push(record.id); offset += length;
+      if (text.length >= maxSegmentChars - 1) flush();
+    }
+  }
+  flush();
+  return { ...selection, segments, maxSegmentChars, budget };
+}

package/vendor/context-engine/src/contracts.mjs

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+
+export class ContextEngineError extends Error {
+  constructor(message, code = 'CTX_INVALID_INPUT', details) {
+    super(message); this.name = 'ContextEngineError'; this.code = code;
+    if (details !== undefined) this.details = details;
+  }
+}
+
+const id = z.string().min(1).max(256);
+const text = z.string().refine(value => value.trim().length > 0, 'Testo vuoto');
+const revision = z.number().int().nonnegative();
+const date = z.iso.datetime({ offset: true });
+const model = z.object({ provider: id, model: id }).catchall(z.json());
+const toolCall = z.object({ id, type: z.literal('function'), function: z.object({ name: id, arguments: z.string() }).catchall(z.json()) }).catchall(z.json());
+const message = z.object({ role: z.enum(['system', 'developer', 'user', 'assistant', 'tool']), content: z.json().optional(), tool_call_id: id.optional(), tool_calls: z.array(toolCall).optional() }).catchall(z.json()).superRefine((value, ctx) => {
+  if (value.role === 'tool' && !value.tool_call_id) ctx.addIssue({ code: 'custom', path: ['tool_call_id'], message: 'Identità della chiamata mancante' });
+});
+
+export const ContextRecordV1 = z.strictObject({ schema: z.literal('talos.context.record.v1').optional(), id, sessionId: id.optional(), sequence: revision.optional(), message, createdAt: date, origin: z.string().optional(), assetRefs: z.array(id).default([]), sha256: z.string().regex(/^[a-f0-9]{64}$/u).optional() });
+export const ContextSettingsV1 = z.strictObject({
+  auto: z.boolean().default(true),
+  model: z.discriminatedUnion('mode', [z.strictObject({ mode: z.literal('follow-session') }), z.strictObject({ mode: z.literal('explicit'), provider: id, model: id })]).default({ mode: 'follow-session' }),
+  triggerRatio: z.number().gt(0).lt(1).default(0.75), targetRatio: z.number().gt(0).lt(1).default(0.55),
+  retainRecentTurns: z.number().int().min(0).max(100).default(2), focus: z.string().max(8000).default(''),
+  nativeMode: z.enum(['off', 'qualified']).default('off'), semanticSearch: z.boolean().default(true),
+}).refine(value => value.targetRatio < value.triggerRatio, { message: 'Obiettivo inferiore alla soglia di avvio richiesto', path: ['targetRatio'] });
+
+export const ContextSourceRefV1 = z.strictObject({ recordId: id, quote: text, start: revision.optional(), end: revision.optional() });
+/** 09/09 — una citazione che non si è potuta verificare non sparisce in silenzio: resta qui, con il motivo. */
+export const ContextUnverifiedSourceV1 = z.strictObject({ recordId: z.string(), quote: z.string(), reason: z.enum(['not-found', 'unknown-record', 'out-of-order']) });
+export const ContextSummaryV1 = z.strictObject({ schema: z.literal('talos.context.summary.v1'), text, goal: text, decisions: z.array(z.string()), constraints: z.array(z.string()), completed: z.array(z.string()), pending: z.array(z.string()), resources: z.array(z.string()), sources: z.array(ContextSourceRefV1), unverifiedSources: z.array(ContextUnverifiedSourceV1).optional() });
+export const TokenMeasurementV1 = z.strictObject({ schema: z.literal('talos.context.tokens.v1'), inputTokens: revision, windowTokens: z.number().int().positive(), responseReserve: revision, method: z.enum(['runtime', 'provider', 'heuristic']), exact: z.boolean(), requestHash: z.string(), provider: id, model: id, estimatedMarginTokens: revision.optional() }).refine(value => value.method !== 'heuristic' || !value.exact, 'La stima euristica non è esatta');
+export const ContextVersionV1 = z.strictObject({ schema: z.literal('talos.context.version.v1'), id, sessionId: id, coveredThrough: revision, sourceIds: z.array(id), sourceHash: z.string().regex(/^[a-f0-9]{64}$/u), summary: ContextSummaryV1, activeMessages: z.array(message), model, measurement: TokenMeasurementV1, createdAt: date, restoredFrom: id.optional() });
+export const ContextJobV1 = z.strictObject({ schema: z.literal('talos.context.job.v1'), id, sessionId: id, idempotencyKey: id, requestFingerprint: z.string(), kind: z.enum(['compact', 'regenerate', 'restore']), state: z.enum(['queued', 'preparing', 'summarizing', 'validating', 'ready', 'committed', 'paused', 'cancelled', 'failed']), baseRevision: revision, baseStateRevision: revision, coveredThrough: revision, model, createdAt: date, updatedAt: date, completedSegments: z.array(z.json()), progress: z.strictObject({ completed: revision, total: revision, phase: z.string() }), error: z.strictObject({ code: id, message: z.string() }).optional(), versionId: id.optional() });
+export const ContextEventV1 = z.strictObject({ schema: z.literal('talos.context.event.v1'), id, sessionId: id, jobId: id.optional(), versionId: id.optional(), kind: id, state: z.string().optional(), createdAt: date, payload: z.json() });
+/** 09/09 — l'ultima misura preparata per la richiesta, con la revisione a cui apparteneva: la UI la mostra come «misurata alle …», e dice se il contesto è cambiato dopo. */
+export const ContextMeasurementV1 = z.strictObject({ schema: z.literal('talos.context.measurement.v1'), revision, measuredAt: date, tokens: TokenMeasurementV1 });
+export const ContextSnapshotV1 = z.object({ schema: z.literal('talos.context.snapshot.v1'), sessionId: id, revision, stateRevision: revision, headSequence: revision, settings: ContextSettingsV1, metadata: z.json(), activeVersion: ContextVersionV1.nullable(), facts: z.array(z.json()), jobs: z.array(ContextJobV1), measurement: ContextMeasurementV1.nullable().optional() }).catchall(z.json());
+
+function parse(schema, value, label) {
+  const result = schema.safeParse(value);
+  if (!result.success) throw new ContextEngineError(`${label} non valido.`, 'CTX_INVALID_INPUT', result.error.issues.map(issue => ({ path: issue.path.join('.'), message: issue.message })));
+  return result.data;
+}
+export function parseContextRecord(value) { return parse(ContextRecordV1, value, 'Messaggio'); }
+export function parseContextSettings(value) { return parse(ContextSettingsV1, value, 'Impostazioni'); }
+export function parseContextSummary(value) { return parse(ContextSummaryV1, value, 'Sintesi'); }