@mr-jones123/toji 0.1.1

package/packages/toji-comms/src/comms/store.ts

@@ -0,0 +1,145 @@
+import type { TojiCommsDatabase } from "../db/connection";
+import type { CliAgentResult, CommsContextType, CommsRequest, CommsThread, CommsThreadContext, CommsTurn } from "./types";
+
+export function getOrCreateThread(database: TojiCommsDatabase, request: CommsRequest): CommsThread {
+  if (request.threadId !== undefined) {
+    const thread = database.query<CommsThread, [number]>(`SELECT * FROM comms_threads WHERE id = ?`).get(request.threadId);
+    if (!thread) throw new Error(`No Toji Comms thread found for id ${request.threadId}.`);
+    return thread;
+  }
+
+  const active = database
+    .query<CommsThread, [string]>(`SELECT * FROM comms_threads WHERE cwd = ? AND status = 'active' ORDER BY updated_at DESC, id DESC LIMIT 1`)
+    .get(request.cwd);
+  if (active) return active;
+
+  database
+    .query(
+      `INSERT INTO comms_threads (title, cwd, session_id, mode, status)
+       VALUES (?, ?, ?, ?, 'active')`,
+    )
+    .run(request.title ?? titleFromRequest(request), request.cwd, request.sessionId ?? null, request.mode ?? "discuss");
+
+  return getThread(database, lastInsertId(database));
+}
+
+export function getThread(database: TojiCommsDatabase, threadId: number): CommsThread {
+  const thread = database.query<CommsThread, [number]>(`SELECT * FROM comms_threads WHERE id = ?`).get(threadId);
+  if (!thread) throw new Error(`No Toji Comms thread found for id ${threadId}.`);
+  return thread;
+}
+
+export function addTurn(
+  database: TojiCommsDatabase,
+  turn: {
+    threadId: number;
+    role: CommsTurn["role"];
+    sourceAgent?: string;
+    provider?: string;
+    model?: string;
+    content: string;
+    contextJson?: unknown;
+  },
+): number {
+  database
+    .query(
+      `INSERT INTO comms_turns (thread_id, role, source_agent, provider, model, content, context_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      turn.threadId,
+      turn.role,
+      turn.sourceAgent ?? null,
+      turn.provider ?? null,
+      turn.model ?? null,
+      turn.content,
+      turn.contextJson ? JSON.stringify(turn.contextJson) : null,
+    );
+  database.query(`UPDATE comms_threads SET updated_at = CURRENT_TIMESTAMP WHERE id = ?`).run(turn.threadId);
+  return lastInsertId(database);
+}
+
+export function getRecentTurns(database: TojiCommsDatabase, threadId: number, limit = 10): CommsTurn[] {
+  return database
+    .query<CommsTurn, [number, number]>(`SELECT * FROM comms_turns WHERE thread_id = ? ORDER BY id DESC LIMIT ?`)
+    .all(threadId, limit)
+    .reverse();
+}
+
+export function addThreadContext(
+  database: TojiCommsDatabase,
+  input: { threadId: number; type: CommsContextType; title: string; content: string; source?: string },
+): number {
+  database
+    .query(
+      `INSERT INTO comms_context (thread_id, type, title, content, source)
+       VALUES (?, ?, ?, ?, ?)`,
+    )
+    .run(input.threadId, input.type, input.title, input.content, input.source ?? null);
+  return lastInsertId(database);
+}
+
+export function listThreadContext(database: TojiCommsDatabase, threadId: number, limit = 10): CommsThreadContext[] {
+  return database
+    .query<CommsThreadContext, [number, number]>(`SELECT * FROM comms_context WHERE thread_id = ? ORDER BY id DESC LIMIT ?`)
+    .all(threadId, limit)
+    .reverse();
+}
+
+export function listThreadContextByIds(database: TojiCommsDatabase, threadId: number, ids: number[]): CommsThreadContext[] {
+  if (ids.length === 0) return [];
+  return database
+    .query<CommsThreadContext, Array<number>>(
+      `SELECT * FROM comms_context
+       WHERE thread_id = ? AND id IN (${ids.map(() => "?").join(", ")})
+       ORDER BY id`,
+    )
+    .all(threadId, ...ids);
+}
+
+export function deleteThreadContext(database: TojiCommsDatabase, id: number): boolean {
+  const result = database.query<{ changes: number }, [number]>(`DELETE FROM comms_context WHERE id = ?`).run(id) as { changes?: number };
+  return (result.changes ?? 0) > 0;
+}
+
+export function clearThreadContext(database: TojiCommsDatabase, threadId: number): void {
+  database.query(`DELETE FROM comms_context WHERE thread_id = ?`).run(threadId);
+}
+
+export function storeRun(
+  database: TojiCommsDatabase,
+  threadId: number,
+  turnId: number | undefined,
+  run: CliAgentResult,
+  targetModel?: string,
+  renderedPrompt = "",
+): void {
+  database
+    .query(
+      `INSERT INTO comms_runs (thread_id, turn_id, target_provider, target_model, command_json, rendered_prompt, exit_code, stdout, stderr, duration_ms)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      threadId,
+      turnId ?? null,
+      run.agent,
+      targetModel ?? null,
+      JSON.stringify(run.command),
+      renderedPrompt,
+      run.exitCode,
+      run.stdout,
+      run.stderr,
+      run.durationMs,
+    );
+}
+
+function titleFromRequest(request: CommsRequest): string {
+  const source = request.title ?? request.context.userRequest ?? request.context.sourceMessage;
+  return source.length > 80 ? `${source.slice(0, 77)}...` : source;
+}
+
+function lastInsertId(database: TojiCommsDatabase): number {
+  const row = database.query<{ id: number }>(`SELECT last_insert_rowid() AS id`).get();
+  if (!row) throw new Error("Unable to read SQLite last_insert_rowid().");
+  return row.id;
+}

package/packages/toji-comms/src/comms/types.ts

@@ -0,0 +1,94 @@
+export interface SourceModelInfo {
+  provider?: string;
+  id?: string;
+}
+
+export type CommsMode = "discuss" | "ask" | "critique" | "decide" | "verify" | "plan";
+export type ContextMode = "brief" | "thread" | "recentTurns" | "threadContext";
+export type CommsContextType = "project_overview" | "graph_result" | "file_snippet" | "decision" | "constraint" | "research_summary" | "benchmark_result" | "user_preference" | "note";
+
+export interface CommsContextPacket {
+  userRequest?: string;
+  sourceMessage: string;
+  knownContext?: string[];
+  questionsForPeer?: string[];
+  contextMode?: ContextMode[];
+}
+
+export type TargetProvider = "mmx" | "claude" | "codex";
+
+export interface CommsRequest {
+  cwd: string;
+  threadId?: number;
+  title?: string;
+  mode?: CommsMode;
+  sourceModel?: SourceModelInfo;
+  sessionId?: string;
+  targetProvider?: TargetProvider;
+  targetModel?: string;
+  system?: string;
+  includeThreadContext?: boolean;
+  contextIds?: number[];
+  context: CommsContextPacket;
+}
+
+export interface CommsThread {
+  id: number;
+  title: string;
+  cwd: string;
+  session_id?: string | null;
+  mode: CommsMode;
+  status: string;
+  summary?: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CommsThreadContext {
+  id: number;
+  thread_id: number;
+  type: CommsContextType;
+  title: string;
+  content: string;
+  source?: string | null;
+  created_at: string;
+}
+
+export interface CommsTurn {
+  id: number;
+  thread_id: number;
+  role: "user" | "source_ai" | "peer_ai" | "system";
+  source_agent?: string | null;
+  provider?: string | null;
+  model?: string | null;
+  content: string;
+  context_json?: string | null;
+  created_at: string;
+}
+
+export interface CliAgentInput {
+  cwd: string;
+  prompt: string;
+  system?: string;
+  model?: string;
+}
+
+export interface CliAgentResult {
+  agent: TargetProvider;
+  command: string[];
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  durationMs: number;
+  reply: string;
+}
+
+export interface CommsResult {
+  threadId: number;
+  sourceTurnId: number;
+  peerTurnId?: number;
+  status: "completed" | "failed";
+  prompt: string;
+  reply: string;
+  run: CliAgentResult;
+}

package/packages/toji-comms/src/db/connection.ts

@@ -0,0 +1,58 @@
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { DatabaseSync, type SQLInputValue, type StatementSync } from "node:sqlite";
+
+import { runMigrations } from "./migrations";
+
+export interface TojiCommsStatement<Result = unknown, Params extends SQLInputValue[] = SQLInputValue[]> {
+  run(...params: Params): unknown;
+  get(...params: Params): Result | undefined;
+  all(...params: Params): Result[];
+}
+
+export interface TojiCommsDatabase {
+  exec(sql: string): void;
+  query<Result = unknown, Params extends SQLInputValue[] = SQLInputValue[]>(sql: string): TojiCommsStatement<Result, Params>;
+  close(): void;
+}
+
+class NodeSqliteDatabase implements TojiCommsDatabase {
+  readonly #database: DatabaseSync;
+
+  constructor(databasePath: string) {
+    this.#database = new DatabaseSync(databasePath, { open: true });
+  }
+
+  exec(sql: string): void {
+    this.#database.exec(sql);
+  }
+
+  query<Result = unknown, Params extends SQLInputValue[] = SQLInputValue[]>(sql: string): TojiCommsStatement<Result, Params> {
+    const statement = this.#database.prepare(sql) as StatementSync;
+    return {
+      run: (...params: Params) => statement.run(...params),
+      get: (...params: Params) => statement.get(...params) as Result | undefined,
+      all: (...params: Params) => statement.all(...params) as Result[],
+    };
+  }
+
+  close(): void {
+    this.#database.close();
+  }
+}
+
+export function getDefaultDatabasePath(): string {
+  return join(homedir(), ".pi", "agent", "toji-comms", "toji-comms.sqlite");
+}
+
+export function openTojiCommsDatabase(databasePath = getDefaultDatabasePath()): TojiCommsDatabase {
+  mkdirSync(dirname(databasePath), { recursive: true });
+
+  const database = new NodeSqliteDatabase(databasePath);
+  database.exec("PRAGMA foreign_keys = ON;");
+  database.exec("PRAGMA journal_mode = WAL;");
+  runMigrations(database);
+
+  return database;
+}

package/packages/toji-comms/src/db/migrations.ts

@@ -0,0 +1,69 @@
+import type { TojiCommsDatabase } from "./connection";
+
+const schema = `
+CREATE TABLE IF NOT EXISTS comms_threads (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  title TEXT NOT NULL,
+  cwd TEXT NOT NULL,
+  session_id TEXT,
+  mode TEXT NOT NULL DEFAULT 'discuss',
+  status TEXT NOT NULL DEFAULT 'active',
+  summary TEXT,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS comms_turns (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  thread_id INTEGER NOT NULL REFERENCES comms_threads(id) ON DELETE CASCADE,
+  role TEXT NOT NULL,
+  source_agent TEXT,
+  provider TEXT,
+  model TEXT,
+  content TEXT NOT NULL,
+  context_json TEXT,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS comms_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  thread_id INTEGER NOT NULL REFERENCES comms_threads(id) ON DELETE CASCADE,
+  turn_id INTEGER REFERENCES comms_turns(id) ON DELETE SET NULL,
+  target_provider TEXT NOT NULL,
+  target_model TEXT,
+  command_json TEXT NOT NULL,
+  rendered_prompt TEXT NOT NULL DEFAULT '',
+  exit_code INTEGER,
+  stdout TEXT NOT NULL DEFAULT '',
+  stderr TEXT NOT NULL DEFAULT '',
+  duration_ms INTEGER NOT NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS comms_context (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  thread_id INTEGER NOT NULL REFERENCES comms_threads(id) ON DELETE CASCADE,
+  type TEXT NOT NULL,
+  title TEXT NOT NULL,
+  content TEXT NOT NULL,
+  source TEXT,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_comms_threads_updated ON comms_threads(updated_at);
+CREATE INDEX IF NOT EXISTS idx_comms_threads_cwd ON comms_threads(cwd, status, updated_at);
+CREATE INDEX IF NOT EXISTS idx_comms_turns_thread ON comms_turns(thread_id, id);
+CREATE INDEX IF NOT EXISTS idx_comms_runs_thread ON comms_runs(thread_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_comms_context_thread ON comms_context(thread_id, created_at);
+`;
+
+export function runMigrations(database: TojiCommsDatabase): void {
+  database.exec(schema);
+  addColumnIfMissing(database, "comms_runs", "rendered_prompt", "TEXT NOT NULL DEFAULT ''");
+}
+
+function addColumnIfMissing(database: TojiCommsDatabase, table: string, column: string, definition: string): void {
+  const columns = database.query<{ name: string }>(`PRAGMA table_info(${table})`).all();
+  if (columns.some((item) => item.name === column)) return;
+  database.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition};`);
+}