agentel 0.2.0 → 0.2.2

package/src/config.js

@@ -194,12 +194,24 @@ function setConfigKey(key, value, env = process.env) {
   const cfg = loadConfig(env);
   const parts = key.split(".").filter(Boolean);
   if (parts.length === 0) throw new Error("config key is required");
+  if (key === "device.name") {
+    const deviceName = String(value || "").trim();
+    if (!deviceName) throw new Error("device.name cannot be empty");
+    cfg.device = {
+      ...(cfg.device || {}),
+      name: deviceName,
+      slug: slugifyDeviceName(deviceName)
+    };
+    cfg.updatedAt = new Date().toISOString();
+    saveConfig(cfg, env);
+    return cfg;
+  }
   let cursor = cfg;
   for (const part of parts.slice(0, -1)) {
     if (!cursor[part] || typeof cursor[part] !== "object") cursor[part] = {};
     cursor = cursor[part];
   }
-  cursor[parts[parts.length - 1]] = parseConfigValue(value);
+  cursor[parts[parts.length - 1]] = normalizeConfigKeyValue(key, parseConfigValue(value));
   cfg.updatedAt = new Date().toISOString();
   saveConfig(cfg, env);
   return cfg;
@@ -228,6 +240,35 @@ function parseConfigValue(value) {
   }
 }
 
+function normalizeConfigKeyValue(key, value) {
+  if (key === "imports.sources") return normalizeImportSources(value);
+  if (key === "imports.defaultSinceDays") return normalizeNonNegativeInteger(value, 30);
+  if (key === "sync.intervalMinutes" || key === "index.intervalMinutes" || key === "index.batteryIntervalMinutes") {
+    return normalizeSyncInterval(value);
+  }
+  if (key === "storage.root") return path.resolve(String(value || ""));
+  return value;
+}
+
+function normalizeImportSources(value) {
+  const raw = Array.isArray(value)
+    ? value
+    : String(value || "")
+      .split(/[,\s]+/)
+      .map((item) => item.trim())
+      .filter(Boolean);
+  const selected = new Set(raw);
+  const ordered = IMPORT_SOURCE_ORDER.filter((source) => selected.has(source));
+  const extras = raw.filter((source) => !ordered.includes(source));
+  return enabledImportSources([...ordered, ...extras]);
+}
+
+function normalizeNonNegativeInteger(value, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0) return fallback;
+  return Math.round(number);
+}
+
 module.exports = {
   defaultConfig,
   effectiveImportSources,

package/src/doctor.js

@@ -1,34 +1,42 @@
 "use strict";
 
 const fs = require("fs");
-const os = require("os");
-const path = require("path");
 const { spawnSync } = require("child_process");
-const { archiveRoot, countSessions } = require("./archive");
+const { archiveRoot, countSessions, listSessions } = require("./archive");
 const { autostartStatus, recallInvocation } = require("./autostart");
 const { loadConfig } = require("./config");
 const { discoverCliHistory } = require("./importers");
+const { canonicalSourceType, parserVersionForSource } = require("./parser-versions");
 const { paths, readJson } = require("./paths");
 const { hasRemoteTarget } = require("./sync");
 
-function runDoctor(env = process.env) {
+function runDoctor(env = process.env, options = {}) {
+  reportProgress(options, "Doctor", "checking configuration", 1, 5);
   const cfg = loadConfig(env);
   const checks = [];
   add(checks, "config", fs.existsSync(paths(env).config), paths(env).config, "Run `agentlog init` to create config.");
   add(checks, "archive", fs.existsSync(archiveRoot(env)), archiveRoot(env), "Run `agentlog import --source all --since 30d` to create the archive.");
-  add(checks, "rg", commandExists("rg"), "ripgrep search", "`agentlog history` will fall back to a slower JS scan.");
+  reportProgress(options, "Doctor", "checking local tools", 2, 5);
+  add(checks, "rg", commandExists("rg"), "ripgrep search", "Install ripgrep with `brew install ripgrep` for faster `agentlog history` search.");
   add(checks, "sqlite3", commandExists("sqlite3"), "Codex, Devin, and Cursor SQLite imports", "Install sqlite3 for Codex, Devin, and Cursor state database imports.");
+  add(checks, "search index", !cfg.index?.paused, cfg.index?.paused ? "paused" : "active", "Run `agentlog index resume` to restart search indexing.");
   add(checks, "collector", Boolean(cfg.collector?.enabled), cfg.collector?.otlpEndpoint || "", "Enable collector with `agentlog config set collector.enabled true`.");
   add(checks, "remote sync", hasRemoteTarget(cfg, env), remoteTargetLabel(cfg), "Configure with `agentlog sync --endpoint ... --bucket ...`.");
+  reportProgress(options, "Doctor", "checking watcher and integrations", 3, 5);
   const auto = autostartStatus();
-  add(checks, "autostart", Boolean(auto.enabled), auto.file || auto.note || "", "Run `agentlog autostart enable` to start at login.");
+  add(checks, "autostart", Boolean(auto.enabled), auto.file || auto.note || "", "Run `agentlog watcher login enable` to start at login.");
   const invocation = recallInvocation();
-  add(checks, "recall command", Boolean(invocation.command), `${invocation.command} ${invocation.args.join(" ")}`, "Install recall with `agentlog recall add-to codex` or `agentlog init`.");
+  add(checks, "recall command", Boolean(invocation.command), `${invocation.command} ${invocation.args.join(" ")}`, "Install recall with `agentlog integrations add-to codex` or `agentlog init`.");
+  reportProgress(options, "Doctor", "checking parser versions", 4, 5);
+  const parsers = parserVersionHealth(env);
+  add(checks, "parser versions", parsers.outdated.length === 0, parserVersionSummary(parsers), parserVersionRemediation(parsers));
 
-  const discovery = discoverCliHistory(env);
+  reportProgress(options, "Doctor", "discovering local sources", 5, 5);
+  const discovery = discoverCliHistory(env, { onProgress: options.onProgress });
   const coverage = sourceCoverage(discovery, cfg);
   const sessions = countSessions(env);
   const importState = readJson(paths(env).imports, { files: {}, sessions: {} });
+  const recommendations = buildRecommendations(checks, coverage, parsers);
   return {
     ok: checks.every((check) => check.status === "ok"),
     home: paths(env).home,
@@ -40,7 +48,9 @@ function runDoctor(env = process.env) {
       trackedSessions: Object.keys(importState.sessions || {}).length,
       trackedFiles: Object.keys(importState.files || {}).length
     },
-    coverage
+    coverage,
+    parsers,
+    recommendations
   };
 }
 
@@ -56,7 +66,10 @@ function sourceCoverage(discovery, cfg) {
     coverageRow("gemini-cli", "Gemini CLI", discovery.geminiCli, configured),
     coverageRow("antigravity", "Antigravity", discovery.antigravity, configured),
     coverageRow("devin-cli", "Devin CLI", discovery.devinCli, configured),
-    coverageRow("cursor", "Cursor", discovery.cursor, configured)
+    coverageRow("cursor", "Cursor", discovery.cursor, configured),
+    coverageRow("cline", "Cline", discovery.cline, configured),
+    coverageRow("opencode", "OpenCode", discovery.opencode, configured),
+    coverageRow("aider", "Aider", discovery.aider, configured)
   ];
   return rows.map((row) => ({
     ...row,
@@ -76,6 +89,139 @@ function coverageRow(source, label, result = {}, configured) {
   };
 }
 
+function parserVersionHealth(env = process.env) {
+  const bySource = new Map();
+  for (const session of listSessions(env)) {
+    for (const [sourceType, archivedVersion] of parserVersionEntries(session)) {
+      const source = canonicalSourceType(sourceType);
+      const currentVersion = parserVersionForSource(source);
+      if (!currentVersion || !archivedVersion || compareVersions(archivedVersion, currentVersion) >= 0) continue;
+      const existing = bySource.get(source) || {
+        sourceType: source,
+        archivedVersion,
+        currentVersion,
+        sessions: 0,
+        command: parserUpdateCommand(source)
+      };
+      if (compareVersions(archivedVersion, existing.archivedVersion) < 0) existing.archivedVersion = archivedVersion;
+      existing.sessions++;
+      bySource.set(source, existing);
+    }
+  }
+  return {
+    outdated: [...bySource.values()].sort((a, b) => a.sourceType.localeCompare(b.sourceType))
+  };
+}
+
+function parserVersionEntries(session = {}) {
+  const entries = [];
+  if (session.parserVersions && typeof session.parserVersions === "object") {
+    entries.push(...Object.entries(session.parserVersions));
+  }
+  if (session.sourceType && session.parserVersion) {
+    entries.push([session.sourceType, session.parserVersion]);
+  }
+  return entries.filter(([sourceType, version]) => sourceType && version);
+}
+
+function parserVersionSummary(parsers) {
+  const outdated = parsers.outdated || [];
+  if (!outdated.length) return "all archived sessions match current parser versions";
+  const sessions = outdated.reduce((sum, item) => sum + item.sessions, 0);
+  return `${outdated.length} parser${outdated.length === 1 ? "" : "s"} behind current code across ${sessions} session${sessions === 1 ? "" : "s"}`;
+}
+
+function parserVersionRemediation(parsers) {
+  const commands = (parsers.outdated || []).map((item) => item.command).filter(Boolean);
+  if (!commands.length) return "Re-run the affected importer, usually `agentlog import --source all --since all`.";
+  const unique = [...new Set(commands)];
+  if (unique.length === 1) return `Run \`${unique[0]}\` to refresh affected archives.`;
+  return "Run the affected import commands listed in Recommendations.";
+}
+
+function buildRecommendations(checks, coverage, parsers) {
+  const recommendations = [];
+  for (const check of checks) {
+    if (check.status !== "warn" || !check.remediation) continue;
+    if (check.name === "parser versions") continue;
+    recommendations.push(recommendationFromRemediation(check.name, check.remediation));
+  }
+  for (const row of coverage) {
+    if (row.status !== "found but disabled") continue;
+    recommendations.push({
+      label: row.label,
+      detail: `${row.sessions} importable session${row.sessions === 1 ? "" : "s"} found, but ${row.source} is not in config.json imports.sources.`,
+      commands: [`agentlog config sources add ${row.source}`, `agentlog import --source ${row.source} --since all`]
+    });
+  }
+  for (const item of parsers.outdated || []) {
+    recommendations.push({
+      label: `Parser ${item.sourceType}`,
+      detail: `${item.sessions} archived session${item.sessions === 1 ? "" : "s"} use parser ${item.archivedVersion}; current parser is ${item.currentVersion}.`,
+      commands: item.command ? [item.command] : ["agentlog import --source all --since all"]
+    });
+  }
+  return dedupeRecommendations(recommendations);
+}
+
+function recommendationFromRemediation(label, remediation) {
+  const commands = [...String(remediation).matchAll(/`([^`]+)`/g)].map((match) => match[1]).filter(Boolean);
+  return {
+    label,
+    detail: String(remediation).replace(/`/g, ""),
+    commands
+  };
+}
+
+function dedupeRecommendations(recommendations) {
+  const seen = new Set();
+  const result = [];
+  for (const item of recommendations) {
+    const key = `${item.label}\n${item.detail}\n${(item.commands || []).join("\n")}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(item);
+  }
+  return result;
+}
+
+function parserUpdateCommand(sourceType) {
+  const source = {
+    "codex-cli-history": "codex-cli",
+    "codex-desktop-history": "codex-desktop",
+    "cli-history": "claude",
+    "claude-sdk-history": "claude-sdk",
+    "claude-code-desktop-metadata": "claude-code-desktop",
+    "claude-workspace-desktop": "claude-workspace",
+    "cursor-workspace-sqlite": "cursor",
+    "cursor-global-sqlite": "cursor",
+    "cursor-raw-sqlite-salvage": "cursor",
+    "cursor-agent-transcripts": "cursor",
+    "devin-cli-history": "devin-cli",
+    "gemini-cli-history": "gemini-cli",
+    "cline-task-history": "cline",
+    "opencode-history": "opencode",
+    "aider-chat-history": "aider",
+    "antigravity-history": "antigravity"
+  }[canonicalSourceType(sourceType)];
+  return source ? `agentlog import --source ${source} --since all` : "";
+}
+
+function compareVersions(a, b) {
+  const left = String(a || "0").split(".").map((part) => Number(part) || 0);
+  const right = String(b || "0").split(".").map((part) => Number(part) || 0);
+  if (left.length !== right.length) {
+    if (left.length === 3 && right.length === 4) return -1;
+    if (left.length === 4 && right.length === 3) return 1;
+  }
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index++) {
+    const diff = (left[index] || 0) - (right[index] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
 function add(checks, name, ok, detail, remediation) {
   checks.push({
     name,
@@ -97,6 +243,17 @@ function remoteTargetLabel(cfg) {
   return `${remote.type || cfg.storage?.backend || "remote"} ${remote.endpoint || remote.url}${remote.bucket ? `/${remote.bucket}` : ""}${device}`;
 }
 
+function reportProgress(options, provider, message, current, total) {
+  if (typeof options.onProgress !== "function") return;
+  options.onProgress({
+    kind: "discovery",
+    provider,
+    current,
+    total,
+    message
+  });
+}
+
 module.exports = {
   runDoctor
 };