@ftarganski/omni-ai 1.1.10 → 1.2.0

package/dist/history.d.ts

@@ -0,0 +1 @@
+export * from '@omni-ai/history';

package/dist/history.js

@@ -0,0 +1,545 @@
+// ../../packages/history/dist/parsers/claude-code.js
+import { readdir, readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { glob } from "glob";
+function extractContent(message) {
+  const raw = message?.content;
+  if (typeof raw === "string")
+    return { content: raw };
+  if (Array.isArray(raw)) {
+    const blocks = raw;
+    const text = blocks.map((b) => {
+      if (b.type === "text")
+        return b.text ?? "";
+      if (b.type === "tool_use")
+        return `[tool_use:${b.name}] ${JSON.stringify(b.input ?? {})}`;
+      if (b.type === "tool_result")
+        return typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+      return "";
+    }).filter(Boolean).join("\n");
+    const toolUse = blocks.find((b) => b.type === "tool_use");
+    return { content: text, toolName: toolUse?.name };
+  }
+  return { content: "" };
+}
+function defaultClaudeCodeRoot() {
+  return join(homedir(), ".claude", "projects");
+}
+async function parseTranscriptFile(file, provider, scope) {
+  const raw = await readFile(file, "utf-8");
+  const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+  const events = [];
+  const citations = [];
+  let ordinal = 0;
+  lines.forEach((line, lineIndex) => {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const type = typeof entry.type === "string" ? entry.type : void 0;
+    const message = entry.message;
+    if (!message || type !== "user" && type !== "assistant")
+      return;
+    const { content, toolName } = extractContent(message);
+    if (!content)
+      return;
+    const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : Number.NaN;
+    events.push({
+      role: message.role ?? type ?? "user",
+      content,
+      toolName,
+      ordinal: ordinal++,
+      timestamp: Number.isNaN(timestamp) ? Date.now() : timestamp
+    });
+    citations.push({ sourcePath: file, sourceLine: lineIndex + 1 });
+  });
+  if (events.length === 0)
+    return null;
+  const sourceSessionId = file.replace(/\.jsonl$/, "").split(/[/\\]/).pop() ?? file;
+  return {
+    session: {
+      id: `${provider}:${scope ?? ""}:${sourceSessionId}`,
+      provider,
+      sourceSessionId,
+      importedAt: Date.now(),
+      scope
+    },
+    events,
+    citations
+  };
+}
+var ClaudeCodeHistoryParser = class {
+  provider = "claude-code";
+  root;
+  constructor(options = {}) {
+    this.root = options.root ?? defaultClaudeCodeRoot();
+  }
+  async discover() {
+    const id = `${this.provider}:${this.root}`;
+    const base = {
+      id,
+      provider: this.provider,
+      path: this.root,
+      nativeImport: true
+    };
+    let entries;
+    try {
+      const info = await stat(this.root);
+      if (!info.isDirectory()) {
+        return [{ ...base, importable: false, reason: "path is not a directory" }];
+      }
+      entries = await readdir(this.root, { withFileTypes: true });
+    } catch {
+      return [{ ...base, importable: false, reason: "history directory not found" }];
+    }
+    const sources = [];
+    const looseFiles = await glob("*.jsonl", { cwd: this.root });
+    if (looseFiles.length > 0) {
+      sources.push({ ...base, importable: true });
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const dir = join(this.root, entry.name);
+      const files = await glob("**/*.jsonl", { cwd: dir });
+      if (files.length === 0)
+        continue;
+      sources.push({
+        id: `${this.provider}:${dir}`,
+        provider: this.provider,
+        path: dir,
+        nativeImport: true,
+        importable: true,
+        scope: entry.name
+      });
+    }
+    if (sources.length === 0) {
+      return [{ ...base, importable: false, reason: "no .jsonl transcripts found" }];
+    }
+    return sources;
+  }
+  async import(source) {
+    const files = await glob("**/*.jsonl", { cwd: source.path, absolute: true });
+    const results = [];
+    for (const file of files) {
+      const result = await parseTranscriptFile(file, source.provider, source.scope);
+      if (result)
+        results.push(result);
+    }
+    return results;
+  }
+};
+
+// ../../packages/history/dist/parsers/codex.js
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { glob as glob2 } from "glob";
+
+// ../../packages/history/dist/store.js
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import Database from "better-sqlite3";
+var sourceFromRow = (r) => ({
+  id: r.id,
+  provider: r.provider,
+  path: r.path,
+  nativeImport: Boolean(r.native_import),
+  importable: Boolean(r.importable),
+  reason: r.reason ?? void 0,
+  scope: r.scope || void 0
+});
+var sessionFromRow = (r) => ({
+  id: r.id,
+  provider: r.provider,
+  sourceSessionId: r.source_session_id,
+  importedAt: r.imported_at,
+  scope: r.scope || void 0
+});
+var eventFromRow = (r) => ({
+  id: r.id,
+  sessionId: r.session_id,
+  role: r.role,
+  content: r.content,
+  toolName: r.tool_name ?? void 0,
+  ordinal: r.ordinal,
+  timestamp: r.ts
+});
+var HistoryStore = class {
+  db;
+  constructor(options = {}) {
+    const path = options.path ?? "./omni-ai-history.db";
+    mkdirSync(dirname(path), { recursive: true });
+    this.db = new Database(path);
+    this.db.pragma("journal_mode = WAL");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sources (
+        id            TEXT PRIMARY KEY,
+        provider      TEXT NOT NULL,
+        path          TEXT NOT NULL,
+        native_import INTEGER NOT NULL,
+        importable    INTEGER NOT NULL,
+        reason        TEXT,
+        scope         TEXT NOT NULL DEFAULT ''
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id                TEXT PRIMARY KEY,
+        provider          TEXT NOT NULL,
+        source_session_id TEXT NOT NULL,
+        imported_at       INTEGER NOT NULL,
+        scope             TEXT NOT NULL DEFAULT '',
+        UNIQUE (provider, scope, source_session_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_sessions_scope ON sessions (scope);
+
+      CREATE TABLE IF NOT EXISTS events (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT    NOT NULL REFERENCES sessions (id),
+        role       TEXT    NOT NULL,
+        content    TEXT    NOT NULL,
+        tool_name  TEXT,
+        ordinal    INTEGER NOT NULL,
+        ts         INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_events_session ON events (session_id, ordinal);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+        content,
+        content='events',
+        content_rowid='id'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS events_ai AFTER INSERT ON events BEGIN
+        INSERT INTO events_fts (rowid, content) VALUES (new.id, new.content);
+      END;
+
+      CREATE TABLE IF NOT EXISTS citations (
+        event_id    INTEGER NOT NULL REFERENCES events (id),
+        source_path TEXT    NOT NULL,
+        source_line INTEGER,
+        PRIMARY KEY (event_id)
+      );
+    `);
+  }
+  upsertSource(source) {
+    this.db.prepare(`INSERT INTO sources (id, provider, path, native_import, importable, reason, scope)
+         VALUES (@id, @provider, @path, @nativeImport, @importable, @reason, @scope)
+         ON CONFLICT (id) DO UPDATE SET
+           provider = excluded.provider,
+           path = excluded.path,
+           native_import = excluded.native_import,
+           importable = excluded.importable,
+           reason = excluded.reason,
+           scope = excluded.scope`).run({
+      id: source.id,
+      provider: source.provider,
+      path: source.path,
+      nativeImport: source.nativeImport ? 1 : 0,
+      importable: source.importable ? 1 : 0,
+      reason: source.reason ?? null,
+      scope: source.scope ?? ""
+    });
+  }
+  listSources(provider) {
+    const rows = provider ? this.db.prepare(`SELECT * FROM sources WHERE provider = ? ORDER BY id`).all(provider) : this.db.prepare(`SELECT * FROM sources ORDER BY provider, id`).all();
+    return rows.map(sourceFromRow);
+  }
+  /** Persists one imported session and its events/citations. Idempotent per (provider, scope, sourceSessionId). */
+  saveImportResult(provider, sessionId, result) {
+    const upsertSession = this.db.prepare(`INSERT INTO sessions (id, provider, source_session_id, imported_at, scope)
+       VALUES (@id, @provider, @sourceSessionId, @importedAt, @scope)
+       ON CONFLICT (provider, scope, source_session_id) DO UPDATE SET imported_at = excluded.imported_at`);
+    const insertEvent = this.db.prepare(`INSERT INTO events (session_id, role, content, tool_name, ordinal, ts)
+       VALUES (@sessionId, @role, @content, @toolName, @ordinal, @ts)`);
+    const insertCitation = this.db.prepare(`INSERT INTO citations (event_id, source_path, source_line)
+       VALUES (@eventId, @sourcePath, @sourceLine)
+       ON CONFLICT (event_id) DO UPDATE SET source_path = excluded.source_path, source_line = excluded.source_line`);
+    const deleteCitations = this.db.prepare(`DELETE FROM citations WHERE event_id IN (SELECT id FROM events WHERE session_id = ?)`);
+    const deleteEvents = this.db.prepare(`DELETE FROM events WHERE session_id = ?`);
+    const run = this.db.transaction(() => {
+      upsertSession.run({
+        id: sessionId,
+        provider,
+        sourceSessionId: result.session.sourceSessionId,
+        importedAt: result.session.importedAt,
+        scope: result.session.scope ?? ""
+      });
+      deleteCitations.run(sessionId);
+      deleteEvents.run(sessionId);
+      result.events.forEach((event, i) => {
+        const info = insertEvent.run({
+          sessionId,
+          role: event.role,
+          content: event.content,
+          toolName: event.toolName ?? null,
+          ordinal: event.ordinal,
+          ts: event.timestamp
+        });
+        const citation = result.citations[i];
+        if (citation) {
+          insertCitation.run({
+            eventId: info.lastInsertRowid,
+            sourcePath: citation.sourcePath,
+            sourceLine: citation.sourceLine ?? null
+          });
+        }
+      });
+    });
+    run();
+  }
+  getSession(id) {
+    const row = this.db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
+    return row ? sessionFromRow(row) : null;
+  }
+  listSessions(options = {}) {
+    const clauses = [];
+    const params = [];
+    if (options.provider) {
+      clauses.push("provider = ?");
+      params.push(options.provider);
+    }
+    if (options.scope) {
+      clauses.push("scope = ?");
+      params.push(options.scope);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(`SELECT * FROM sessions ${where} ORDER BY imported_at DESC`).all(...params);
+    return rows.map(sessionFromRow);
+  }
+  listEvents(sessionId) {
+    const rows = this.db.prepare(`SELECT * FROM events WHERE session_id = ? ORDER BY ordinal ASC`).all(sessionId);
+    return rows.map(eventFromRow);
+  }
+  getEvent(id) {
+    const row = this.db.prepare(`SELECT * FROM events WHERE id = ?`).get(id);
+    return row ? eventFromRow(row) : null;
+  }
+  /** Events immediately before/after `id` within the same session, `id` included. */
+  getEventWindow(id, window) {
+    const center = this.getEvent(id);
+    if (!center)
+      return [];
+    const rows = this.db.prepare(`SELECT * FROM events
+         WHERE session_id = ? AND ordinal BETWEEN ? AND ?
+         ORDER BY ordinal ASC`).all(center.sessionId, center.ordinal - window, center.ordinal + window);
+    return rows.map(eventFromRow);
+  }
+  getCitation(eventId) {
+    const row = this.db.prepare(`SELECT * FROM citations WHERE event_id = ?`).get(eventId);
+    return row ? { eventId: row.event_id, sourcePath: row.source_path, sourceLine: row.source_line ?? void 0 } : null;
+  }
+  /**
+   * Full-text search over event content. Session-diverse by default: at most `groupLimit`
+   * hits per session so one large session can't crowd out the rest of the result page.
+   *
+   * Scoped by default in spirit — callers (CLI, MCP skills) are expected to pass `scope`
+   * for project-aware providers so an agent working in one project never sees another
+   * project's imported history. Omitting `scope` searches across every scope.
+   */
+  search(query, options = {}) {
+    const limit = options.limit ?? 20;
+    const groupLimit = options.groupLimit ?? 3;
+    const clauses = ["fts.content MATCH @query"];
+    const params = { query };
+    if (options.sessionId) {
+      clauses.push("e.session_id = @sessionId");
+      params.sessionId = options.sessionId;
+    }
+    if (options.scope) {
+      clauses.push("s.scope = @scope");
+      params.scope = options.scope;
+    }
+    const rows = this.db.prepare(`SELECT e.*, rank AS score FROM events_fts fts
+         JOIN events e ON e.id = fts.rowid
+         JOIN sessions s ON s.id = e.session_id
+         WHERE ${clauses.join(" AND ")}
+         ORDER BY rank`).all(params);
+    const perSession = /* @__PURE__ */ new Map();
+    const sessionCache = /* @__PURE__ */ new Map();
+    const hits = [];
+    for (const row of rows) {
+      if (hits.length >= limit)
+        break;
+      const count = perSession.get(row.session_id) ?? 0;
+      if (count >= groupLimit)
+        continue;
+      let session = sessionCache.get(row.session_id);
+      if (session === void 0) {
+        session = this.getSession(row.session_id);
+        sessionCache.set(row.session_id, session);
+      }
+      if (!session)
+        continue;
+      perSession.set(row.session_id, count + 1);
+      hits.push({ event: eventFromRow(row), session, score: row.score });
+    }
+    return hits;
+  }
+  listCitations() {
+    const rows = this.db.prepare(`SELECT * FROM citations`).all();
+    return rows.map((r) => ({
+      eventId: r.event_id,
+      sourcePath: r.source_path,
+      sourceLine: r.source_line ?? void 0
+    }));
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// ../../packages/history/dist/skills.js
+function defaultHistoryDbPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+  return `${home}/.omni-ai/history.db`;
+}
+function encodeProjectScope(absPath) {
+  return absPath.replace(/[^a-zA-Z0-9]/g, "-");
+}
+var searchHistorySkill = {
+  name: "search-history",
+  description: "Full-text search over already-imported third-party AI agent history (run `omni history import` first to populate it). Scoped to the caller's own project by default \u2014 pass allProjects:true to search every imported project.",
+  async execute(input) {
+    const scope = input.allProjects ? void 0 : input.scope ?? encodeProjectScope(process.cwd());
+    const store = new HistoryStore({ path: defaultHistoryDbPath() });
+    try {
+      const hits = store.search(input.query, { scope, limit: input.limit });
+      return { scope: scope ?? null, hits };
+    } finally {
+      store.close();
+    }
+  }
+};
+var showEventSkill = {
+  name: "show-history-event",
+  description: "Show one imported history event with N events of surrounding context. Refuses events that belong to a different project scope than the caller's, unless allProjects:true is passed.",
+  async execute(input) {
+    const store = new HistoryStore({ path: defaultHistoryDbPath() });
+    try {
+      const center = store.getEvent(input.eventId);
+      if (!center)
+        return { events: [] };
+      if (!input.allProjects) {
+        const session = store.getSession(center.sessionId);
+        const callerScope = encodeProjectScope(process.cwd());
+        if (session?.scope && session.scope !== callerScope) {
+          throw new Error(`Event ${input.eventId} belongs to a different project scope ("${session.scope}"). Pass allProjects:true to override.`);
+        }
+      }
+      return { events: store.getEventWindow(input.eventId, input.window ?? 3) };
+    } finally {
+      store.close();
+    }
+  }
+};
+
+// ../../packages/history/dist/parsers/codex.js
+function defaultCodexRoot() {
+  return join2(homedir2(), ".codex", "sessions");
+}
+var CodexHistoryParser = class {
+  provider = "codex";
+  root;
+  constructor(options = {}) {
+    this.root = options.root ?? defaultCodexRoot();
+  }
+  async discover() {
+    const id = `${this.provider}:${this.root}`;
+    const base = {
+      id,
+      provider: this.provider,
+      path: this.root,
+      nativeImport: true
+    };
+    try {
+      const info = await stat2(this.root);
+      if (!info.isDirectory()) {
+        return [{ ...base, importable: false, reason: "path is not a directory" }];
+      }
+    } catch {
+      return [{ ...base, importable: false, reason: "history directory not found" }];
+    }
+    const files = await glob2("*.json", { cwd: this.root });
+    if (files.length === 0) {
+      return [{ ...base, importable: false, reason: "no session state files found" }];
+    }
+    return [{ ...base, importable: true }];
+  }
+  async import(source) {
+    const files = await glob2("*.json", { cwd: source.path, absolute: true });
+    const results = [];
+    for (const file of files) {
+      let parsed;
+      try {
+        parsed = JSON.parse(await readFile2(file, "utf-8"));
+      } catch {
+        continue;
+      }
+      const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+      const events = [];
+      const citations = [];
+      let ordinal = 0;
+      for (const m of messages) {
+        if (!m || typeof m.content !== "string" || !m.content)
+          continue;
+        const timestamp = typeof m.timestamp === "string" ? Date.parse(m.timestamp) : Number.NaN;
+        events.push({
+          role: m.role ?? "user",
+          content: m.content,
+          toolName: m.toolName,
+          ordinal: ordinal++,
+          timestamp: Number.isNaN(timestamp) ? Date.now() : timestamp
+        });
+        citations.push({ sourcePath: file });
+      }
+      if (events.length === 0)
+        continue;
+      const sourceSessionId = parsed.id ?? file.replace(/\.json$/, "").split(/[/\\]/).pop() ?? file;
+      const scope = parsed.cwd ? encodeProjectScope(parsed.cwd) : void 0;
+      results.push({
+        session: {
+          id: `${source.provider}:${scope ?? ""}:${sourceSessionId}`,
+          provider: source.provider,
+          sourceSessionId,
+          importedAt: Date.now(),
+          scope
+        },
+        events,
+        citations
+      });
+    }
+    return results;
+  }
+};
+
+// ../../packages/history/dist/registry.js
+var HistoryParserRegistry = class {
+  parsers = /* @__PURE__ */ new Map();
+  register(parser) {
+    this.parsers.set(parser.provider, parser);
+  }
+  get(provider) {
+    return this.parsers.get(provider);
+  }
+  list() {
+    return [...this.parsers.values()];
+  }
+};
+export {
+  ClaudeCodeHistoryParser,
+  CodexHistoryParser,
+  HistoryParserRegistry,
+  HistoryStore,
+  defaultClaudeCodeRoot,
+  defaultCodexRoot,
+  encodeProjectScope,
+  searchHistorySkill,
+  showEventSkill
+};

package/dist/index.d.ts

@@ -10,6 +10,7 @@ import '@omni-ai/skills/backend';
 import '@omni-ai/skills/frontend';
 import '@omni-ai/skills/qa';
 import '@omni-ai/memory';
+import '@omni-ai/history';
 import '@omni-ai/mcp';
 import '@omni-ai/provider-anthropic';
 import '@omni-ai/provider-openai';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ftarganski/omni-ai",
-  "version": "1.1.10",
+  "version": "1.2.0",
   "description": "Provider-agnostic AI agents and skills framework",
   "type": "module",
   "exports": {
@@ -52,6 +52,10 @@
       "import": "./dist/memory.js",
       "types": "./dist/memory.d.ts"
     },
+    "./history": {
+      "import": "./dist/history.js",
+      "types": "./dist/history.d.ts"
+    },
     "./mcp": {
       "import": "./dist/mcp.js",
       "types": "./dist/mcp.d.ts"
@@ -89,14 +93,15 @@
     "glob": "^11.0.0",
     "yaml": "^2.7.0",
     "zod": "^3.24.0",
-    "@omni-ai/core": "0.1.0",
-    "@omni-ai/memory": "0.1.0",
-    "@omni-ai/mcp": "0.1.0",
     "@omni-ai/cli": "0.1.0",
+    "@omni-ai/history": "0.1.0",
     "@omni-ai/provider-anthropic": "0.1.0",
     "@omni-ai/provider-google": "0.1.0",
+    "@omni-ai/core": "0.1.0",
+    "@omni-ai/mcp": "0.1.0",
+    "@omni-ai/skills": "0.1.0",
     "@omni-ai/provider-openai": "0.1.0",
-    "@omni-ai/skills": "0.1.0"
+    "@omni-ai/memory": "0.1.0"
   },
   "peerDependencies": {
     "@anthropic-ai/sdk": "^0.39.0",