agentcache 0.4.2 → 0.5.0-beta.2

package/dist/chunk-JUDLOBOC.js

@@ -1,77 +0,0 @@
-import {
-  getDataDir
-} from "./chunk-T4COG3XD.js";
-
-// src/utils/background-compile.ts
-import { spawn } from "child_process";
-import { existsSync, writeFileSync, readFileSync, unlinkSync, openSync, closeSync, constants } from "fs";
-import { join } from "path";
-var LOCK_FILE = "compile-all.lock";
-var STALE_THRESHOLD_MS = 4 * 60 * 60 * 1e3;
-function getLockPath() {
-  return join(getDataDir(), LOCK_FILE);
-}
-function isLocked() {
-  const lockPath = getLockPath();
-  if (!existsSync(lockPath)) return false;
-  try {
-    const content = readFileSync(lockPath, "utf-8");
-    const { pid, startedAt } = JSON.parse(content);
-    if (Date.now() - startedAt > STALE_THRESHOLD_MS) {
-      unlinkSync(lockPath);
-      return false;
-    }
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch {
-      unlinkSync(lockPath);
-      return false;
-    }
-  } catch {
-    unlinkSync(lockPath);
-    return false;
-  }
-}
-function spawnCompileAll() {
-  if (isLocked()) return false;
-  const agentcacheBin = process.argv[1]?.replace(/\/dist\/.*/, "/dist/cli.js") || "agentcache";
-  const isLinkedBinary = agentcacheBin.includes("dist/cli.js");
-  const cmd = isLinkedBinary ? process.execPath : "agentcache";
-  const args = isLinkedBinary ? [agentcacheBin, "compile-all"] : ["compile-all"];
-  const child = spawn(cmd, args, {
-    detached: true,
-    stdio: "ignore",
-    env: { ...process.env, AGENTCACHE_BACKGROUND: "1" }
-  });
-  child.unref();
-  try {
-    writeFileSync(getLockPath(), JSON.stringify({ pid: child.pid, startedAt: Date.now() }));
-  } catch {
-  }
-  return true;
-}
-function acquireLock() {
-  if (isLocked()) return false;
-  try {
-    const fd = openSync(getLockPath(), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL);
-    const data = JSON.stringify({ pid: process.pid, startedAt: Date.now() });
-    writeFileSync(fd, data);
-    closeSync(fd);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function releaseLock() {
-  try {
-    unlinkSync(getLockPath());
-  } catch {
-  }
-}
-
-export {
-  spawnCompileAll,
-  acquireLock,
-  releaseLock
-};

package/dist/chunk-KFQGP6VL.js

@@ -1,33 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-export {
-  __require,
-  __esm,
-  __export,
-  __toCommonJS
-};

package/dist/chunk-PSASDZQE.js

@@ -1,490 +0,0 @@
-// src/storage/sqlite.ts
-import Database from "better-sqlite3";
-var SqliteKnowledgeRepository = class {
-  db;
-  constructor(dbPath) {
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
-    this.initSchema();
-  }
-  initSchema() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        project TEXT NOT NULL,
-        started_at INTEGER NOT NULL,
-        ended_at INTEGER NOT NULL,
-        git_branch TEXT,
-        git_commit TEXT,
-        provider TEXT NOT NULL DEFAULT 'claude',
-        model TEXT NOT NULL,
-        transcript_path TEXT NOT NULL,
-        observation_count INTEGER NOT NULL DEFAULT 0
-      );
-
-      CREATE TABLE IF NOT EXISTS observations (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL REFERENCES sessions(id),
-        timestamp INTEGER NOT NULL,
-        type TEXT NOT NULL,
-        content TEXT NOT NULL,
-        source_quote TEXT NOT NULL,
-        confidence TEXT NOT NULL,
-        project TEXT NOT NULL,
-        scope TEXT NOT NULL DEFAULT 'project'
-      );
-
-      CREATE TABLE IF NOT EXISTS knowledge_items (
-        id TEXT PRIMARY KEY,
-        canonical_hash TEXT NOT NULL UNIQUE,
-        type TEXT NOT NULL,
-        title TEXT NOT NULL,
-        content TEXT NOT NULL,
-        confidence TEXT NOT NULL DEFAULT 'low',
-        observation_count INTEGER NOT NULL DEFAULT 1,
-        authority TEXT NOT NULL DEFAULT 'AUTO',
-        status TEXT NOT NULL DEFAULT 'active',
-        superseded_by_id TEXT,
-        enforce INTEGER NOT NULL DEFAULT 0,
-        project TEXT NOT NULL,
-        scope TEXT NOT NULL DEFAULT 'project',
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        last_seen_at INTEGER NOT NULL,
-        metadata TEXT NOT NULL DEFAULT '{}'
-      );
-
-      CREATE TABLE IF NOT EXISTS compile_runs (
-        id TEXT PRIMARY KEY,
-        project TEXT NOT NULL,
-        session_id TEXT REFERENCES sessions(id),
-        compiler_version TEXT NOT NULL,
-        prompt_versions TEXT NOT NULL DEFAULT '{}',
-        started_at INTEGER NOT NULL,
-        ended_at INTEGER NOT NULL,
-        duration_ms INTEGER NOT NULL,
-        observations_processed INTEGER NOT NULL DEFAULT 0,
-        knowledge_created INTEGER NOT NULL DEFAULT 0,
-        knowledge_reinforced INTEGER NOT NULL DEFAULT 0,
-        knowledge_deprecated INTEGER NOT NULL DEFAULT 0,
-        knowledge_superseded INTEGER NOT NULL DEFAULT 0,
-        knowledge_ignored INTEGER NOT NULL DEFAULT 0,
-        contradictions_detected INTEGER NOT NULL DEFAULT 0,
-        diagnostics TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS contradictions (
-        id TEXT PRIMARY KEY,
-        project TEXT NOT NULL,
-        item_a_id TEXT NOT NULL,
-        item_b_id TEXT NOT NULL,
-        topic TEXT NOT NULL,
-        description TEXT NOT NULL,
-        recommendation TEXT NOT NULL,
-        resolved INTEGER NOT NULL DEFAULT 0,
-        created_at INTEGER NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS pending_transcripts (
-        id TEXT PRIMARY KEY,
-        transcript_path TEXT NOT NULL UNIQUE,
-        project TEXT NOT NULL,
-        project_root TEXT NOT NULL,
-        provider TEXT NOT NULL,
-        queued_at INTEGER NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project);
-      CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
-      CREATE INDEX IF NOT EXISTS idx_knowledge_project ON knowledge_items(project);
-      CREATE INDEX IF NOT EXISTS idx_knowledge_enforce ON knowledge_items(enforce);
-      CREATE INDEX IF NOT EXISTS idx_knowledge_status ON knowledge_items(status);
-      CREATE INDEX IF NOT EXISTS idx_ki_scope_status ON knowledge_items(scope, status);
-      CREATE INDEX IF NOT EXISTS idx_ki_project_status ON knowledge_items(project, status);
-      CREATE INDEX IF NOT EXISTS idx_compile_runs_project ON compile_runs(project);
-      CREATE INDEX IF NOT EXISTS idx_contradictions_project ON contradictions(project, resolved);
-    `);
-  }
-  saveSession(session) {
-    this.db.prepare(
-      `INSERT INTO sessions (id, project, started_at, ended_at, git_branch, git_commit, provider, model, transcript_path, observation_count)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      session.id,
-      session.project,
-      session.startedAt,
-      session.endedAt,
-      session.gitBranch,
-      session.gitCommit,
-      session.provider,
-      session.model,
-      session.transcriptPath,
-      session.observationCount
-    );
-  }
-  getSession(id) {
-    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
-    if (!row) return null;
-    return this.mapSession(row);
-  }
-  updateSessionTranscriptPath(sessionId, transcriptPath) {
-    this.db.prepare("UPDATE sessions SET transcript_path = ? WHERE id = ?").run(transcriptPath, sessionId);
-  }
-  getCompiledTranscriptPaths(project) {
-    const rows = this.db.prepare("SELECT transcript_path FROM sessions WHERE project = ? AND transcript_path != ''").all(project);
-    return rows.map((r) => r.transcript_path);
-  }
-  getAllCompiledTranscriptPaths() {
-    const rows = this.db.prepare("SELECT transcript_path FROM sessions WHERE transcript_path != ''").all();
-    return rows.map((r) => r.transcript_path);
-  }
-  saveObservation(obs) {
-    this.db.prepare(
-      `INSERT INTO observations (id, session_id, timestamp, type, content, source_quote, confidence, project, scope)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      obs.id,
-      obs.sessionId,
-      obs.timestamp,
-      obs.type,
-      obs.content,
-      obs.sourceQuote,
-      obs.confidence,
-      obs.project,
-      obs.scope
-    );
-  }
-  saveObservations(obs) {
-    const insert = this.db.prepare(
-      `INSERT INTO observations (id, session_id, timestamp, type, content, source_quote, confidence, project, scope)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    );
-    const transaction = this.db.transaction((observations) => {
-      for (const o of observations) {
-        insert.run(
-          o.id,
-          o.sessionId,
-          o.timestamp,
-          o.type,
-          o.content,
-          o.sourceQuote,
-          o.confidence,
-          o.project,
-          o.scope
-        );
-      }
-    });
-    transaction(obs);
-  }
-  getObservations(project, since) {
-    let sql = "SELECT * FROM observations WHERE project = ?";
-    const params = [project];
-    if (since !== void 0) {
-      sql += " AND timestamp >= ?";
-      params.push(since);
-    }
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => this.mapObservation(row));
-  }
-  saveKnowledgeItem(item) {
-    this.db.prepare(
-      `INSERT INTO knowledge_items (id, canonical_hash, type, title, content, confidence, observation_count, authority, status, superseded_by_id, enforce, project, scope, created_at, updated_at, last_seen_at, metadata)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      item.id,
-      item.canonicalHash,
-      item.type,
-      item.title,
-      item.content,
-      item.confidence,
-      item.observationCount,
-      item.authority,
-      item.status,
-      item.supersededById ?? null,
-      item.enforce ? 1 : 0,
-      item.project,
-      item.scope,
-      item.createdAt,
-      item.updatedAt,
-      item.lastSeenAt,
-      JSON.stringify(item.metadata)
-    );
-  }
-  updateKnowledgeItem(id, patch) {
-    const fieldMap = {
-      canonicalHash: "canonical_hash",
-      type: "type",
-      title: "title",
-      content: "content",
-      confidence: "confidence",
-      observationCount: "observation_count",
-      authority: "authority",
-      status: "status",
-      supersededById: "superseded_by_id",
-      enforce: "enforce",
-      project: "project",
-      scope: "scope",
-      createdAt: "created_at",
-      updatedAt: "updated_at",
-      lastSeenAt: "last_seen_at",
-      metadata: "metadata"
-    };
-    const setClauses = [];
-    const values = [];
-    for (const [key, value] of Object.entries(patch)) {
-      const column = fieldMap[key];
-      if (!column) continue;
-      setClauses.push(`${column} = ?`);
-      if (key === "enforce") {
-        values.push(value ? 1 : 0);
-      } else if (key === "metadata") {
-        values.push(JSON.stringify(value));
-      } else {
-        values.push(value);
-      }
-    }
-    if (setClauses.length === 0) return;
-    values.push(id);
-    this.db.prepare(`UPDATE knowledge_items SET ${setClauses.join(", ")} WHERE id = ?`).run(...values);
-  }
-  getKnowledgeItems(project, filter) {
-    let sql = "SELECT * FROM knowledge_items WHERE project = ?";
-    const params = [project];
-    if (filter) {
-      if (filter.type !== void 0) {
-        sql += " AND type = ?";
-        params.push(filter.type);
-      }
-      if (filter.status !== void 0) {
-        sql += " AND status = ?";
-        params.push(filter.status);
-      }
-      if (filter.enforce !== void 0) {
-        sql += " AND enforce = ?";
-        params.push(filter.enforce ? 1 : 0);
-      }
-      if (filter.authority !== void 0) {
-        sql += " AND authority = ?";
-        params.push(filter.authority);
-      }
-    }
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => this.mapKnowledgeItem(row));
-  }
-  getKnowledgeItem(id) {
-    const row = this.db.prepare("SELECT * FROM knowledge_items WHERE id = ?").get(id);
-    if (!row) return null;
-    return this.mapKnowledgeItem(row);
-  }
-  getKnowledgeForContext(project, opts) {
-    const decayThreshold = Date.now() - 30 * 24 * 60 * 60 * 1e3;
-    this.db.prepare(
-      `UPDATE knowledge_items SET status = 'archived', updated_at = ?
-       WHERE status = 'active' AND authority = 'AUTO' AND last_seen_at < ?`
-    ).run(Date.now(), decayThreshold);
-    const authorityFilter = opts?.userOnly ? `AND authority = 'USER'` : `AND (authority = 'USER' OR observation_count >= 2)`;
-    const rows = this.db.prepare(
-      `SELECT * FROM knowledge_items WHERE status = 'active'
-         AND (scope = 'global' OR project = ?)
-         ${authorityFilter}
-         ORDER BY
-           CASE authority WHEN 'USER' THEN 0 ELSE 1 END,
-           CASE confidence WHEN 'high' THEN 3 WHEN 'medium' THEN 2 ELSE 1 END DESC,
-           last_seen_at DESC
-         LIMIT 50`
-    ).all(project);
-    return rows.map((row) => this.mapKnowledgeItem(row));
-  }
-  getEnforcedRules(project) {
-    const rows = this.db.prepare(
-      `SELECT * FROM knowledge_items WHERE enforce = 1 AND status = 'active'
-         AND (scope = 'global' OR project = ?)
-         AND (authority = 'USER' OR observation_count >= 2)`
-    ).all(project);
-    return rows.map((row) => this.mapKnowledgeItem(row));
-  }
-  saveCompileRun(run) {
-    this.db.prepare(
-      `INSERT INTO compile_runs (id, project, session_id, compiler_version, prompt_versions, started_at, ended_at, duration_ms, observations_processed, knowledge_created, knowledge_reinforced, knowledge_deprecated, knowledge_superseded, knowledge_ignored, contradictions_detected, diagnostics)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      run.id,
-      run.project,
-      run.sessionId,
-      run.compilerVersion,
-      JSON.stringify(run.promptVersions),
-      run.startedAt,
-      run.endedAt,
-      run.durationMs,
-      run.observationsProcessed,
-      run.knowledgeCreated,
-      run.knowledgeReinforced,
-      run.knowledgeDeprecated,
-      run.knowledgeSuperseded,
-      run.knowledgeIgnored,
-      run.contradictionsDetected,
-      run.diagnostics
-    );
-  }
-  getCompileRuns(project, limit) {
-    let sql = "SELECT * FROM compile_runs WHERE project = ? ORDER BY started_at DESC";
-    const params = [project];
-    if (limit !== void 0) {
-      sql += " LIMIT ?";
-      params.push(limit);
-    }
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => this.mapCompileRun(row));
-  }
-  saveContradiction(report) {
-    this.db.prepare(
-      `INSERT INTO contradictions (id, project, item_a_id, item_b_id, topic, description, recommendation, resolved, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      report.id,
-      report.project,
-      report.itemAId,
-      report.itemBId,
-      report.topic,
-      report.description,
-      report.recommendation,
-      report.resolved ? 1 : 0,
-      report.createdAt
-    );
-  }
-  getUnresolvedContradictions(project) {
-    const rows = this.db.prepare("SELECT * FROM contradictions WHERE project = ? AND resolved = 0").all(project);
-    return rows.map((row) => this.mapContradiction(row));
-  }
-  resolveContradiction(id) {
-    this.db.prepare("UPDATE contradictions SET resolved = 1 WHERE id = ?").run(id);
-  }
-  queueTranscript(entry) {
-    this.db.prepare(
-      `INSERT OR IGNORE INTO pending_transcripts (id, transcript_path, project, project_root, provider, queued_at)
-         VALUES (?, ?, ?, ?, ?, ?)`
-    ).run(entry.id, entry.transcriptPath, entry.project, entry.projectRoot, entry.provider, entry.queuedAt);
-  }
-  popPendingTranscript() {
-    const row = this.db.prepare("SELECT * FROM pending_transcripts ORDER BY queued_at ASC LIMIT 1").get();
-    if (!row) return null;
-    this.db.prepare("DELETE FROM pending_transcripts WHERE id = ?").run(row.id);
-    return {
-      id: row.id,
-      transcriptPath: row.transcript_path,
-      project: row.project,
-      projectRoot: row.project_root,
-      provider: row.provider,
-      queuedAt: row.queued_at
-    };
-  }
-  getPendingCount() {
-    const row = this.db.prepare("SELECT COUNT(*) as count FROM pending_transcripts").get();
-    return row.count;
-  }
-  grandfatherExistingItems() {
-    this.db.prepare(
-      `UPDATE knowledge_items SET observation_count = 2 WHERE authority = 'AUTO' AND observation_count < 2 AND status = 'active'`
-    ).run();
-  }
-  getQuarantinedItems(project) {
-    const sql = project ? `SELECT * FROM knowledge_items WHERE status = 'active' AND authority = 'AUTO' AND observation_count < 2 AND (scope = 'global' OR project = ?) ORDER BY created_at DESC` : `SELECT * FROM knowledge_items WHERE status = 'active' AND authority = 'AUTO' AND observation_count < 2 ORDER BY created_at DESC`;
-    const rows = project ? this.db.prepare(sql).all(project) : this.db.prepare(sql).all();
-    return rows.map((row) => this.mapKnowledgeItem(row));
-  }
-  promoteItem(id) {
-    this.db.prepare("UPDATE knowledge_items SET authority = 'USER', updated_at = ? WHERE id = ?").run(Date.now(), id);
-  }
-  getProjectStats() {
-    return this.db.prepare("SELECT project, COUNT(*) as count FROM knowledge_items WHERE status = 'active' GROUP BY project ORDER BY count DESC").all();
-  }
-  close() {
-    this.db.close();
-  }
-  mapSession(row) {
-    return {
-      id: row.id,
-      project: row.project,
-      startedAt: row.started_at,
-      endedAt: row.ended_at,
-      gitBranch: row.git_branch,
-      gitCommit: row.git_commit,
-      provider: row.provider,
-      model: row.model,
-      transcriptPath: row.transcript_path,
-      observationCount: row.observation_count
-    };
-  }
-  mapObservation(row) {
-    return {
-      id: row.id,
-      sessionId: row.session_id,
-      timestamp: row.timestamp,
-      type: row.type,
-      content: row.content,
-      sourceQuote: row.source_quote,
-      confidence: row.confidence,
-      project: row.project,
-      scope: row.scope || "project"
-    };
-  }
-  mapKnowledgeItem(row) {
-    return {
-      id: row.id,
-      canonicalHash: row.canonical_hash,
-      type: row.type,
-      title: row.title,
-      content: row.content,
-      confidence: row.confidence,
-      observationCount: row.observation_count,
-      authority: row.authority,
-      status: row.status,
-      supersededById: row.superseded_by_id ?? void 0,
-      enforce: row.enforce === 1,
-      project: row.project,
-      scope: row.scope || "project",
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-      lastSeenAt: row.last_seen_at,
-      metadata: JSON.parse(row.metadata)
-    };
-  }
-  mapCompileRun(row) {
-    return {
-      id: row.id,
-      project: row.project,
-      sessionId: row.session_id,
-      compilerVersion: row.compiler_version,
-      promptVersions: JSON.parse(row.prompt_versions),
-      startedAt: row.started_at,
-      endedAt: row.ended_at,
-      durationMs: row.duration_ms,
-      observationsProcessed: row.observations_processed,
-      knowledgeCreated: row.knowledge_created,
-      knowledgeReinforced: row.knowledge_reinforced,
-      knowledgeDeprecated: row.knowledge_deprecated,
-      knowledgeSuperseded: row.knowledge_superseded,
-      knowledgeIgnored: row.knowledge_ignored,
-      contradictionsDetected: row.contradictions_detected,
-      diagnostics: row.diagnostics
-    };
-  }
-  mapContradiction(row) {
-    return {
-      id: row.id,
-      project: row.project,
-      itemAId: row.item_a_id,
-      itemBId: row.item_b_id,
-      topic: row.topic,
-      description: row.description,
-      recommendation: row.recommendation,
-      resolved: row.resolved === 1,
-      createdAt: row.created_at
-    };
-  }
-};
-
-export {
-  SqliteKnowledgeRepository
-};