trajectories 0.0.0 → 0.1.1

package/legacy/src/managed.ts

@@ -0,0 +1,178 @@
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { mkdir, realpath, stat } from 'node:fs/promises';
+import { parseArgs } from 'node:util';
+import { getSession, listSessions, getHeadMetadata, readCanonicalSession } from '../../dist/log.js';
+import type { ConversationRecord, HeadMetadata, ManagedSession, PageCursor } from '../../dist/log-types.js';
+import type { CanonicalRecord } from '@letta-ai/trajectory';
+import { resolveCanonicalDbPath } from './canonical.js';
+import { TrajectoryDb } from './db.js';
+import { TrajectoryReader } from './reader.js';
+import { aggregateIngestDiagnostics } from './diagnostics.js';
+import { ensurePrivateDirectory } from './private-storage.js';
+import { acquireWriterLease, isMemoryStorePath } from './writer-lease.js';
+import type { CanonicalDbRecord, SessionRecord } from './types.js';
+
+const help = `trajectories index --store <directory> [--db <sqlite-file>] [--robot]
+  Index each managed session's current immutable head in the existing search DB.
+  Re-run after importing completed history; this does not watch or run an agent.
+  Search IDs are managed:<central-id>; accepted history remains in its session log.
+trajectories show <central-id> --store <directory> [--robot]
+trajectories show <indexed-id> [--db <sqlite-file>] [--robot]
+  Read a complete conversation. --store reads the accepted canonical log directly;
+  otherwise show uses the read-only search DB. --robot/--json retains all records.
+`;
+
+function storeRoot(value?: string): string {
+  return resolve(value ?? process.env.TRAJECTORIES_HOME ?? join(process.env.XDG_DATA_HOME ?? join(homedir(), '.local', 'share'), 'trajectories'));
+}
+
+function logPath(root: string, id: string): string { return join(root, 'logs', `${id}.jsonl`); }
+type CanonicalConversationRecord = ConversationRecord & { canonical: CanonicalRecord };
+
+async function history(root: string, session: ManagedSession): Promise<CanonicalConversationRecord[]> {
+  const records: CanonicalConversationRecord[] = [];
+  let cursor: PageCursor | undefined;
+  do {
+    const page = await readCanonicalSession(root, session.id, { atHead: session.head, view: 'history', cursor, limit: 1000 });
+    records.push(...page.items);
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor);
+  return records;
+}
+
+async function sessionsAtRead(root: string): Promise<ManagedSession[]> {
+  const sessions: ManagedSession[] = [];
+  let cursor: PageCursor | undefined;
+  do {
+    const page = await listSessions(root, { cursor, limit: 1000 });
+    sessions.push(...page.items);
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor);
+  return sessions;
+}
+
+/** Stable central identity, isolated from native-session and record identities. */
+function project(session: ManagedSession, accepted: readonly CanonicalConversationRecord[], root: string, metadata: HeadMetadata): { session: SessionRecord; records: CanonicalDbRecord[] } {
+  const id = `managed:${session.id}`;
+  // The index origin is central. Native record.source_type remains unchanged;
+  // keeping this source separate also isolates native admission tombstones.
+  const source = 'managed';
+  const records: CanonicalDbRecord[] = accepted.map(({ id: centralId, canonical: record, origin }, index) => ({
+    id: `${id}:${centralId}`, session_id: id,
+    source_type: origin.harness, native_session_id: origin.nativeSessionId ?? null, binding_id: origin.bindingId ?? null,
+    record_type: record.record_type,
+    stable_source_record_id: record.stable_source_record_id ?? null,
+    source_identity_kind: record.source_identity_kind ?? null,
+    // Native order restarts after a handoff. The pinned accepted page order is
+    // authoritative for the complete logical conversation.
+    source_order_id: String(index).padStart(16, '0'), component_index: record.component_index,
+    record_timestamp: record.record_timestamp ?? null, source_timestamp: record.source_timestamp ?? null,
+    content: record.content ?? null, tool_call_id: record.tool_call_id ?? null, tool_name: record.tool_name ?? null,
+    tool_arguments_json: record.tool_arguments_json ?? null, tool_result_json: record.tool_result_json ?? null,
+    tool_result_ok: record.tool_result_ok === true ? 1 : record.tool_result_ok === false ? 0 : null,
+    record_json: record.record_json, content_hash: record.content_hash, record_hash: record.record_hash,
+  }));
+  const timestamps = records.map(record => record.source_timestamp).filter((value): value is string => !!value).sort();
+  const model = metadata.nativeMeta?.role === 'meta' ? metadata.nativeMeta.model : undefined;
+  return { records, session: {
+    id, source, source_path: logPath(root, session.id),
+    content_hash: createHash('sha256').update(`managed-log-head-v1:${session.head}`).digest('hex'),
+    title: records.find(record => record.record_type === 'user' && record.content?.trim())?.content?.slice(0, 120) ?? `Managed session ${session.id}`,
+    cwd: session.workspace, model: typeof model === 'string' ? model : null,
+    started_at: timestamps[0] ?? null, ended_at: timestamps.at(-1) ?? null,
+    record_count: records.length, created_at: session.createdAt, updated_at: session.updatedAt,
+  }};
+}
+
+function printRecords(id: string, source: string, path: string, records: ReadonlyArray<{
+  record_type: string; source_timestamp?: string | null; content?: string | null;
+  tool_call_id?: string | null; tool_name?: string | null; tool_arguments_json?: string | null;
+  tool_result_json?: string | null; record_json: string; source_type?: string;
+  native_session_id?: string | null;
+}>): void {
+  console.log(`Session: ${id}\nSource: ${source}\nHistory: ${path}`);
+  for (const record of records) {
+    if (record.record_type === 'meta') continue;
+    const label = [record.source_timestamp, record.record_type, record.source_type, record.native_session_id, record.tool_name, record.tool_call_id].filter(Boolean).join(' ');
+    const body = record.record_type === 'assistant-tool-call' ? record.tool_arguments_json ?? record.record_json
+      : record.content ?? record.tool_result_json ?? record.record_json;
+    console.log(`\n[${label}]\n${body}`);
+  }
+}
+
+export async function runManagedCli(command: 'index' | 'show', argv: string[]): Promise<void> {
+  const { values, positionals } = parseArgs({ args: argv, allowPositionals: true, strict: true, options: {
+    store: { type: 'string' }, db: { type: 'string' }, robot: { type: 'boolean' }, json: { type: 'boolean' },
+    help: { type: 'boolean', short: 'h' },
+  }});
+  if (values.help) { console.log(help); return; }
+  const json = values.robot || values.json;
+  const emit = (value: unknown) => console.log(JSON.stringify(value, null, values.robot ? undefined : 2));
+  if (command === 'show') {
+    if (positionals.length !== 1) throw new Error('show requires exactly one session id.');
+    const id = positionals[0]!;
+    if (values.store) {
+      if (values.db) throw new Error('show accepts either --store or --db.');
+      const root = storeRoot(values.store);
+      const session = await getSession(root, id.startsWith('managed:') ? id.slice(8) : id);
+      const records = await history(root, session);
+      const metadata = await getHeadMetadata(root, session.id, { atHead: session.head });
+      if (json) emit({ session, head: session.head, records: records.map(({ canonical, ...record }) => record),
+        diagnostics: metadata.diagnostics, record_format: 'canonical-log', managed_log_path: logPath(root, session.id),
+      });
+      else printRecords(session.id, 'managed', logPath(root, session.id), records.map(({ canonical, origin }) => ({
+        ...canonical, source_type: origin.harness, native_session_id: origin.nativeSessionId,
+      })));
+      return;
+    }
+    const reader = new TrajectoryReader(values.db ?? resolveCanonicalDbPath());
+    try {
+      const session = reader.getSession(id);
+      if (!session) throw new Error(`No indexed session ${id}. Use show <central-id> --store <directory> for an unindexed managed session.`);
+      const records = reader.getSessionRecords(id);
+      if (json) emit({ session, records, record_format: 'ledger-db',
+        ...(session.source === 'managed' ? { managed_log_path: session.source_path } : {}),
+      });
+      else printRecords(id, session.source, session.source_path, records);
+    } finally { reader.close(); }
+    return;
+  }
+  if (positionals.length) throw new Error('index accepts no positional arguments.');
+  const root = await realpath(storeRoot(values.store));
+  const sessions = await sessionsAtRead(root);
+  if (!(await stat(join(root, 'format.json'))).isFile()) throw new Error('Managed store format marker is missing.');
+  // Validate all selected immutable heads before opening a writer. Keep one
+  // conversation in memory at a time, including complete tool output.
+  for (const session of sessions) {
+    await history(root, session);
+    await getHeadMetadata(root, session.id, { atHead: session.head });
+  }
+  const dbPath = values.db ?? resolveCanonicalDbPath();
+  if (!isMemoryStorePath(dbPath)) {
+    if (!values.db && !process.env.TRAJECTORIES_DB && !process.env.LEDGER_DB) ensurePrivateDirectory(dirname(dbPath));
+    else await mkdir(dirname(dbPath), { recursive: true, mode: 0o700 });
+  }
+  const lease = isMemoryStorePath(dbPath) ? null : acquireWriterLease(dbPath, { holder: 'trajectories index' });
+  try {
+    const db = new TrajectoryDb(dbPath);
+    try {
+      const results: Array<{ session_id: string; head: string; outcome: string; records: number }> = [];
+      for (const session of sessions) {
+        const id = `managed:${session.id}`;
+        if (db.getTombstone(id)) { results.push({ session_id: id, head: session.head, outcome: 'deleted', records: 0 }); continue; }
+        const accepted = await history(root, session);
+        const metadata = await getHeadMetadata(root, session.id, { atHead: session.head });
+        const projected = project(session, accepted, root, metadata);
+        const saved = db.saveSession(projected.session, projected.records, aggregateIngestDiagnostics(metadata.diagnostics));
+        results.push({ session_id: id, head: session.head, outcome: saved.inserted ? 'inserted' : saved.updated ? 'updated' : 'unchanged', records: projected.records.length });
+      }
+      if (json) emit({ store: root, db: dbPath, sessions: results, embeddings: 'not generated; lexical index only' });
+      else {
+        for (const result of results) console.log(`${result.outcome}: ${result.session_id} (${result.records} records; head ${result.head})`);
+        console.log(`Indexed ${results.length} managed sessions in ${dbPath}.`);
+      }
+    } finally { db.close(); }
+  } finally { lease?.close(); }
+}

package/legacy/src/native/common.ts

@@ -0,0 +1,68 @@
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+import type { Diagnostic } from "@letta-ai/trajectory";
+import type { ParentageDiagnostic } from "../parentage.js";
+
+export const MAX_NATIVE_BYTES = 64 * 1024 * 1024;
+export const MAX_NATIVE_RECORDS = 100_000;
+
+/** A deterministic input/schema/budget failure, not a transient database or filesystem error. */
+export class NativeInputError extends Error {}
+
+export interface NativeReadOptions { maxBytes?: number }
+export interface NativeDiscoveryOptions {
+  limit: number;
+  /** Select a bounded discovery page after native deduplication, without decoding bodies. */
+  select?: (items: import("../types.js").DiscoveredSession[]) => import("../types.js").DiscoveredSession[];
+  onDiagnostic?: (diagnostic: ParentageDiagnostic) => void;
+}
+export interface NativeTranscript {
+  transcript: string;
+  title?: string;
+  cwd?: string;
+  model?: string;
+  startedAt?: string;
+  endedAt?: string;
+  /**
+   * Input the reader dropped while assembling, in the normalizer's own
+   * vocabulary: the session's stored diagnostics are the library's plus these,
+   * so a reader's typed skips reach coverage instead of vanishing.
+   */
+  diagnostics?: Diagnostic[];
+}
+
+export function nativeByteLimit(options: NativeReadOptions = {}): number {
+  const limit = options.maxBytes ?? MAX_NATIVE_BYTES;
+  if (!Number.isSafeInteger(limit) || limit < 1) throw new RangeError("Native input byte limit must be positive.");
+  return limit;
+}
+
+export function readBoundedText(path: string, maxBytes = MAX_NATIVE_BYTES): string {
+  const fd = openSync(path, "r");
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > maxBytes) throw new NativeInputError("Native input exceeds the byte limit or is not a file.");
+    const buffer = Buffer.alloc(stat.size);
+    let offset = 0;
+    while (offset < buffer.length) {
+      const read = readSync(fd, buffer, offset, buffer.length - offset, offset);
+      if (!read) throw new Error("Native input changed while reading.");
+      offset += read;
+    }
+    if (readSync(fd, Buffer.alloc(1), 0, 1, offset)) throw new Error("Native input changed while reading.");
+    return buffer.toString("utf8").replace(/^\uFEFF/, "");
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export function object(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function safeNativeId(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0 && value !== "." && value !== ".." && !/[\x00-\x1f/\\]/.test(value);
+}
+
+export function reportNativeError(options: NativeDiscoveryOptions, sourcePath: string): void {
+  options.onDiagnostic?.({ code: "read_error", sourcePath, message: "Native history could not be read; coverage may be incomplete." });
+}