agenr 0.9.21 → 0.9.23

package/dist/chunk-RM5SLLEM.js

@@ -0,0 +1,241 @@
+// src/utils/entry-utils.ts
+var MILLISECONDS_PER_DAY = 1e3 * 60 * 60 * 24;
+function toNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim()) {
+    return Number(value);
+  }
+  return Number.NaN;
+}
+function toStringValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return String(value);
+  }
+  return "";
+}
+function toRowsAffected(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    return Number(value);
+  }
+  return 0;
+}
+function parseDaysBetween(now, pastIso) {
+  if (!pastIso) {
+    return 0;
+  }
+  const parsed = new Date(pastIso);
+  if (Number.isNaN(parsed.getTime())) {
+    return 0;
+  }
+  const delta = (now.getTime() - parsed.getTime()) / MILLISECONDS_PER_DAY;
+  if (!Number.isFinite(delta)) {
+    return 0;
+  }
+  return Math.max(delta, 0);
+}
+
+// src/db/co-recall.ts
+var DEFAULT_EDGE_INCREMENT = 0.1;
+var MAX_USED_ENTRIES = 20;
+var MIN_EDGE_WEIGHT = 0.05;
+var CO_RECALL_EDGE_TYPE = "co_recalled";
+function normalizePair(a, b) {
+  return a < b ? [a, b] : [b, a];
+}
+async function strengthenCoRecallEdges(db, usedEntryIds, timestamp) {
+  const uniqueIds = Array.from(
+    new Set(
+      usedEntryIds.map((id) => id.trim()).filter((id) => id.length > 0)
+    )
+  ).slice(0, MAX_USED_ENTRIES);
+  if (uniqueIds.length < 2) {
+    return;
+  }
+  const now = timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const pairs = [];
+  for (let i = 0; i < uniqueIds.length; i += 1) {
+    const a = uniqueIds[i];
+    if (!a) {
+      continue;
+    }
+    for (let j = i + 1; j < uniqueIds.length; j += 1) {
+      const b = uniqueIds[j];
+      if (!b || a === b) {
+        continue;
+      }
+      pairs.push(normalizePair(a, b));
+    }
+  }
+  if (pairs.length === 0) {
+    return;
+  }
+  await db.execute("BEGIN");
+  try {
+    for (const [entryA, entryB] of pairs) {
+      await db.execute({
+        sql: `
+          INSERT INTO co_recall_edges (
+            entry_a, entry_b, edge_type, weight, session_count, last_co_recalled, created_at
+          )
+          VALUES (?, ?, ?, ?, 1, ?, ?)
+          ON CONFLICT
+          DO UPDATE SET
+            weight = MIN(co_recall_edges.weight + excluded.weight, 1.0),
+            session_count = co_recall_edges.session_count + 1,
+            last_co_recalled = excluded.last_co_recalled
+        `,
+        args: [
+          entryA,
+          entryB,
+          CO_RECALL_EDGE_TYPE,
+          DEFAULT_EDGE_INCREMENT,
+          now,
+          now
+        ]
+      });
+    }
+    await db.execute("COMMIT");
+  } catch (error) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+}
+async function decayCoRecallEdges(db, decayFactor = 0.95) {
+  if (!Number.isFinite(decayFactor) || decayFactor < 0) {
+    throw new Error("decayFactor must be a finite number >= 0");
+  }
+  await db.execute("BEGIN");
+  try {
+    await db.execute({
+      sql: `
+        UPDATE co_recall_edges
+        SET weight = weight * ?
+        WHERE edge_type = ?
+      `,
+      args: [decayFactor, CO_RECALL_EDGE_TYPE]
+    });
+    const pruned = await db.execute({
+      sql: `
+        DELETE FROM co_recall_edges
+        WHERE edge_type = ?
+          AND weight < ?
+      `,
+      args: [CO_RECALL_EDGE_TYPE, MIN_EDGE_WEIGHT]
+    });
+    await db.execute("COMMIT");
+    return toRowsAffected(pruned.rowsAffected);
+  } catch (error) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+}
+async function getCoRecallNeighbors(db, entryId, minWeight = 0.1, limit = 10) {
+  const normalizedId = entryId.trim();
+  if (!normalizedId) {
+    return [];
+  }
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 10;
+  const safeMinWeight = Number.isFinite(minWeight) ? Math.max(minWeight, 0) : 0.1;
+  const result = await db.execute({
+    sql: `
+      SELECT
+        CASE WHEN entry_a = ? THEN entry_b ELSE entry_a END AS neighbor_id,
+        weight,
+        session_count,
+        last_co_recalled
+      FROM co_recall_edges
+      WHERE edge_type = ?
+        AND (entry_a = ? OR entry_b = ?)
+        AND weight >= ?
+      ORDER BY weight DESC, session_count DESC, last_co_recalled DESC
+      LIMIT ?
+    `,
+    args: [normalizedId, CO_RECALL_EDGE_TYPE, normalizedId, normalizedId, safeMinWeight, safeLimit]
+  });
+  return result.rows.map((row) => ({
+    entryId: toStringValue(row.neighbor_id),
+    weight: toNumber(row.weight),
+    sessionCount: toNumber(row.session_count),
+    lastCoRecalled: toStringValue(row.last_co_recalled)
+  }));
+}
+async function getCoRecallEdgeCounts(db) {
+  const result = await db.execute({
+    sql: `
+      SELECT entry_id, COUNT(*) AS edge_count
+      FROM (
+        SELECT entry_a AS entry_id
+        FROM co_recall_edges
+        WHERE edge_type = ?
+        UNION ALL
+        SELECT entry_b AS entry_id
+        FROM co_recall_edges
+        WHERE edge_type = ?
+      )
+      GROUP BY entry_id
+    `,
+    args: [CO_RECALL_EDGE_TYPE, CO_RECALL_EDGE_TYPE]
+  });
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const entryId = toStringValue(row.entry_id).trim();
+    if (!entryId) {
+      continue;
+    }
+    counts.set(entryId, Math.max(0, toNumber(row.edge_count)));
+  }
+  return counts;
+}
+async function getTopCoRecallEdges(db, limit = 20) {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 20;
+  const result = await db.execute({
+    sql: `
+      SELECT entry_a, entry_b, weight, session_count, last_co_recalled
+      FROM co_recall_edges
+      WHERE edge_type = ?
+      ORDER BY weight DESC, session_count DESC, last_co_recalled DESC
+      LIMIT ?
+    `,
+    args: [CO_RECALL_EDGE_TYPE, safeLimit]
+  });
+  return result.rows.map((row) => ({
+    entryA: toStringValue(row.entry_a),
+    entryB: toStringValue(row.entry_b),
+    weight: toNumber(row.weight),
+    sessionCount: toNumber(row.session_count),
+    lastCoRecalled: toStringValue(row.last_co_recalled)
+  }));
+}
+
+export {
+  toNumber,
+  toStringValue,
+  toRowsAffected,
+  parseDaysBetween,
+  MAX_USED_ENTRIES,
+  strengthenCoRecallEdges,
+  decayCoRecallEdges,
+  getCoRecallNeighbors,
+  getCoRecallEdgeCounts,
+  getTopCoRecallEdges
+};

package/dist/cli-main.js

@@ -18,6 +18,7 @@ import {
   describeAuth,
   dropFtsTriggersAndIndex,
   embed,
+  evolveQualityScores,
   getAuthMethodDefinition,
   getDb,
   getOldestPendingReviewCreatedAt,
@@ -49,14 +50,14 @@ import {
   setStoredCredential,
   walCheckpoint,
   writeConfig
-} from "./chunk-EY2VW6OI.js";
+} from "./chunk-56GW7EIS.js";
 import {
   getCoRecallNeighbors,
   getTopCoRecallEdges,
   parseDaysBetween,
   toNumber,
   toStringValue
-} from "./chunk-QYZIPFIA.js";
+} from "./chunk-RM5SLLEM.js";
 
 // src/cli-main.ts
 import fs37 from "fs/promises";
@@ -1527,6 +1528,49 @@ async function runDbCheckCommand(options, deps) {
     resolvedDeps.closeDbFn(db);
   }
 }
+async function runDbEvolveQualityCommand(options, deps) {
+  const resolvedDeps = {
+    readConfigFn: deps?.readConfigFn ?? readConfig,
+    getDbFn: deps?.getDbFn ?? getDb,
+    initDbFn: deps?.initDbFn ?? initDb,
+    initSchemaFn: deps?.initSchemaFn ?? initSchema,
+    closeDbFn: deps?.closeDbFn ?? closeDb,
+    backupDbFn: deps?.backupDbFn ?? backupDb,
+    resetDbFn: deps?.resetDbFn ?? resetDb
+  };
+  const dryRun = options.dryRun === true;
+  const config = resolvedDeps.readConfigFn(process.env);
+  const configured = resolveDbPathFromOptions(options.db, config?.db?.path);
+  const db = resolvedDeps.getDbFn(configured);
+  try {
+    await resolvedDeps.initDbFn(db);
+    const evolved = await evolveQualityScores(db, { dryRun });
+    const summary = {
+      updated: evolved.updated,
+      dryRun,
+      stats: evolved.stats
+    };
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(summary, null, 2)}
+`);
+    } else {
+      process.stdout.write(
+        `Updated ${summary.updated} entries. Avg quality: ${summary.stats.avgBefore.toFixed(2)} -> ${summary.stats.avgAfter.toFixed(2)}. High: ${summary.stats.high}, Medium: ${summary.stats.medium}, Low: ${summary.stats.low}
+`
+      );
+      if (dryRun) {
+        process.stdout.write("Dry-run mode enabled - no changes were written.\n");
+      }
+    }
+    return summary;
+  } catch (error) {
+    throw new Error(
+      `Failed to evolve quality scores: ${error instanceof Error ? error.message : String(error)}`
+    );
+  } finally {
+    resolvedDeps.closeDbFn(db);
+  }
+}
 
 // src/commands/watcher.ts
 import { execFile, spawn } from "child_process";
@@ -19188,7 +19232,7 @@ async function runIngestCommand(inputPaths, options, deps) {
             try {
               const existingIds = await queue.runExclusive(() => getSourceEntryIds(db, target.file));
               if (existingIds.size >= 2) {
-                const { strengthenCoRecallEdges, MAX_USED_ENTRIES } = await import("./co-recall-IFMEHHZ2.js");
+                const { strengthenCoRecallEdges, MAX_USED_ENTRIES } = await import("./co-recall-2UNFBE7S.js");
                 const idArr = [...existingIds].slice(0, MAX_USED_ENTRIES);
                 const expectedEdges = idArr.length * (idArr.length - 1) / 2;
                 const edgeCount = await queue.runExclusive(async () => {
@@ -19366,7 +19410,7 @@ async function runIngestCommand(inputPaths, options, deps) {
         try {
           const fileEntryIds = await queue.runExclusive(() => getSourceEntryIds(db, target.file));
           if (fileEntryIds.size >= 2) {
-            const { strengthenCoRecallEdges } = await import("./co-recall-IFMEHHZ2.js");
+            const { strengthenCoRecallEdges } = await import("./co-recall-2UNFBE7S.js");
             const edgeTimestamp = resolvedDeps.nowFn().toISOString();
             await queue.runExclusive(() => strengthenCoRecallEdges(db, [...fileEntryIds], edgeTimestamp));
           }
@@ -26238,6 +26282,10 @@ function createProgram() {
     const result = await runDbRebuildIndexCommand({ db: opts.db });
     process.exitCode = result.exitCode;
   });
+  dbCommand.command("evolve-quality").description("Recompute quality scores from recall activity and co-recall graph signals").option("--db <path>", "Database path override").option("--dry-run", "Compute and print score changes without writing", false).option("--json", "Print machine-readable output", false).action(async (opts) => {
+    await runDbEvolveQualityCommand({ db: opts.db, dryRun: opts.dryRun, json: opts.json });
+    process.exitCode = 0;
+  });
   program.command("setup").description("Interactive setup for provider/auth/task-model defaults").action(async () => {
     await runSetup(process.env);
   });

package/dist/co-recall-2UNFBE7S.js

@@ -0,0 +1,16 @@
+import {
+  MAX_USED_ENTRIES,
+  decayCoRecallEdges,
+  getCoRecallEdgeCounts,
+  getCoRecallNeighbors,
+  getTopCoRecallEdges,
+  strengthenCoRecallEdges
+} from "./chunk-RM5SLLEM.js";
+export {
+  MAX_USED_ENTRIES,
+  decayCoRecallEdges,
+  getCoRecallEdgeCounts,
+  getCoRecallNeighbors,
+  getTopCoRecallEdges,
+  strengthenCoRecallEdges
+};