vibeusage 0.2.23 → 0.3.1

package/src/lib/integrations/gemini.js

@@ -0,0 +1,86 @@
+const {
+  isGeminiHookConfigured,
+  upsertGeminiHook,
+  removeGeminiHook,
+} = require("../gemini-config");
+const { isDir, isFile } = require("./utils");
+
+module.exports = {
+  name: "gemini",
+  summaryLabel: "Gemini",
+  statusLabel: "Gemini hooks",
+  async probe(ctx) {
+    const hasConfigDir = await isDir(ctx.gemini.configDir);
+    if (!hasConfigDir) {
+      return baseProbe(this, { status: "not_installed", detail: "Config not found" });
+    }
+    const configured = await isGeminiHookConfigured({
+      settingsPath: ctx.gemini.settingsPath,
+      hookCommand: ctx.gemini.hookCommand,
+    });
+    return baseProbe(this, {
+      status: configured ? "ready" : "drifted",
+      detail: configured ? "Hooks installed" : "Run vibeusage init to reconcile hooks",
+      configured,
+    });
+  },
+  async install(ctx) {
+    if (!(await isDir(ctx.gemini.configDir))) {
+      return action(this, "skipped", false, "Config not found");
+    }
+    const result = await upsertGeminiHook({
+      settingsPath: ctx.gemini.settingsPath,
+      hookCommand: ctx.gemini.hookCommand,
+    });
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Hooks installed" : "Hooks already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isDir(ctx.gemini.configDir))) {
+      return action(this, "skipped", false, "config dir not found");
+    }
+    const result = await removeGeminiHook({
+      settingsPath: ctx.gemini.settingsPath,
+      hookCommand: ctx.gemini.hookCommand,
+    });
+    if (result.removed) {
+      return action(this, "removed", true, ctx.gemini.settingsPath);
+    }
+    if (result.skippedReason === "hook-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "settings.json not found");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}

package/src/lib/integrations/index.js

@@ -0,0 +1,85 @@
+const { createIntegrationContext } = require("./context");
+const codex = require("./codex");
+const everyCode = require("./every-code");
+const claude = require("./claude");
+const gemini = require("./gemini");
+const opencode = require("./opencode");
+const openclawSession = require("./openclaw-session");
+const openclawLegacy = require("./openclaw-legacy");
+
+const INTEGRATIONS = [
+  codex,
+  everyCode,
+  claude,
+  gemini,
+  opencode,
+  openclawSession,
+  openclawLegacy,
+];
+
+function listIntegrations() {
+  return INTEGRATIONS.slice();
+}
+
+async function probeIntegrations(context) {
+  const ctx = await ensureContext(context);
+  const results = [];
+  for (const integration of INTEGRATIONS) {
+    results.push(await integration.probe(ctx));
+  }
+  return results;
+}
+
+async function installIntegrations(context) {
+  const ctx = await ensureContext(context);
+  const results = [];
+  for (const integration of INTEGRATIONS) {
+    results.push(await integration.install(ctx));
+  }
+  return results;
+}
+
+async function uninstallIntegrations(context) {
+  const ctx = await ensureContext(context);
+  const results = [];
+  for (const integration of INTEGRATIONS) {
+    results.push(await integration.uninstall(ctx));
+  }
+  return results;
+}
+
+function summarizeProbeForInitPreview(probe) {
+  switch (probe.status) {
+    case "ready":
+      return { label: probe.summaryLabel, status: "set", detail: "Already configured" };
+    case "not_installed":
+      if (probe.initPreviewStatus) {
+        return {
+          label: probe.summaryLabel,
+          status: probe.initPreviewStatus,
+          detail: probe.initPreviewDetail || probe.detail,
+        };
+      }
+      return { label: probe.summaryLabel, status: "skipped", detail: probe.detail };
+    case "unsupported_legacy":
+      return { label: probe.summaryLabel, status: "updated", detail: "Will replace legacy config" };
+    case "unreadable":
+      return { label: probe.summaryLabel, status: "skipped", detail: probe.detail || "Config unreadable" };
+    default:
+      return { label: probe.summaryLabel, status: "updated", detail: "Will reconcile config" };
+  }
+}
+
+async function ensureContext(context) {
+  if (context?.trackerPaths && context?.notifyPath) return context;
+  return createIntegrationContext(context);
+}
+
+module.exports = {
+  listIntegrations,
+  createIntegrationContext,
+  probeIntegrations,
+  installIntegrations,
+  uninstallIntegrations,
+  summarizeProbeForInitPreview,
+};

package/src/lib/integrations/openclaw-legacy.js

@@ -0,0 +1,123 @@
+const { probeOpenclawHookState, removeOpenclawHookConfig } = require("../openclaw-hook");
+
+module.exports = {
+  name: "openclaw-legacy",
+  summaryLabel: "OpenClaw Hook (legacy)",
+  statusLabel: "OpenClaw hook (legacy)",
+  async probe(ctx) {
+    const state = await probeOpenclawHookState({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
+    });
+    if (state?.skippedReason === "openclaw-config-missing") {
+      return baseProbe(this, { status: "not_installed", detail: "OpenClaw config not found" });
+    }
+    if (state?.skippedReason === "openclaw-config-unreadable") {
+      return baseProbe(this, {
+        status: "unreadable",
+        detail: state.error
+          ? `OpenClaw config unreadable: ${state.error}`
+          : "OpenClaw config unreadable",
+        linked: Boolean(state.linked),
+        enabled: Boolean(state.enabled),
+      });
+    }
+    if (state?.configured || state?.linked || state?.enabled) {
+      return baseProbe(this, {
+        status: "unsupported_legacy",
+        detail: "Legacy OpenClaw hook detected; run vibeusage init",
+        linked: Boolean(state.linked),
+        enabled: Boolean(state.enabled),
+      });
+    }
+    return baseProbe(this, { status: "not_installed", detail: "Legacy hook not installed" });
+  },
+  async install(ctx) {
+    const state = await probeOpenclawHookState({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
+    });
+    if (state?.skippedReason === "openclaw-config-unreadable") {
+      return action(
+        this,
+        "skipped",
+        false,
+        state.error ? `OpenClaw config unreadable: ${state.error}` : "OpenClaw config unreadable",
+        { skippedReason: state.skippedReason },
+      );
+    }
+    if (!(state?.configured || state?.linked || state?.enabled)) {
+      return action(this, "unchanged", false, "no change");
+    }
+    const result = await removeOpenclawHookConfig({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
+    });
+    if (result?.removed) {
+      return action(this, "updated", true, "Removed legacy command hook");
+    }
+    if (result?.skippedReason === "openclaw-config-unreadable") {
+      return action(
+        this,
+        "skipped",
+        false,
+        result.error ? `OpenClaw config unreadable: ${result.error}` : "OpenClaw config unreadable",
+        { skippedReason: result.skippedReason },
+      );
+    }
+    return action(this, "unchanged", false, "no change");
+  },
+  async uninstall(ctx) {
+    const result = await removeOpenclawHookConfig({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
+    });
+    if (result?.removed) {
+      return action(this, "removed", true, result.openclawConfigPath);
+    }
+    if (result?.skippedReason === "openclaw-config-missing") {
+      return action(this, "skipped", false, "openclaw config not found", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    if (result?.skippedReason === "openclaw-config-unreadable") {
+      return action(
+        this,
+        "skipped",
+        false,
+        result.error ? `openclaw config unreadable: ${result.error}` : "openclaw config unreadable",
+        { skippedReason: result.skippedReason },
+      );
+    }
+    return action(this, "unchanged", false, "no change");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}

package/src/lib/integrations/openclaw-session.js

@@ -0,0 +1,132 @@
+const {
+  installOpenclawSessionPlugin,
+  probeOpenclawSessionPluginState,
+  removeOpenclawSessionPluginConfig,
+} = require("../openclaw-session-plugin");
+
+module.exports = {
+  name: "openclaw-session",
+  summaryLabel: "OpenClaw Session Plugin",
+  statusLabel: "OpenClaw session plugin",
+  async probe(ctx) {
+    const state = await probeOpenclawSessionPluginState({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
+    });
+    if (state?.skippedReason === "openclaw-config-missing") {
+      return baseProbe(this, { status: "not_installed", detail: "OpenClaw config not found" });
+    }
+    if (state?.skippedReason === "openclaw-config-unreadable") {
+      return baseProbe(this, {
+        status: "unreadable",
+        detail: state.error
+          ? `OpenClaw config unreadable: ${state.error}`
+          : "OpenClaw config unreadable",
+        linked: Boolean(state.linked),
+        enabled: Boolean(state.enabled),
+      });
+    }
+    if (state?.configured) {
+      return baseProbe(this, {
+        status: "ready",
+        detail: "Session plugin linked",
+        configured: true,
+        linked: Boolean(state.linked),
+        enabled: Boolean(state.enabled),
+      });
+    }
+    return baseProbe(this, {
+      status: "drifted",
+      detail: "Run vibeusage init to reconcile session plugin",
+      linked: Boolean(state?.linked),
+      enabled: Boolean(state?.enabled),
+    });
+  },
+  async install(ctx) {
+    const before = await probeOpenclawSessionPluginState({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
+    });
+    const result = await installOpenclawSessionPlugin({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      packageName: "vibeusage",
+      env: ctx.env,
+    });
+    if (result?.skippedReason === "openclaw-cli-missing") {
+      return action(this, "skipped", false, "OpenClaw CLI not found");
+    }
+    if (result?.skippedReason === "openclaw-plugins-install-failed") {
+      return action(this, "skipped", false, `Install failed: ${result.error || "unknown error"}`);
+    }
+    if (result?.skippedReason === "openclaw-config-unreadable") {
+      return action(
+        this,
+        "skipped",
+        false,
+        result.error ? `OpenClaw config unreadable: ${result.error}` : "OpenClaw config unreadable",
+      );
+    }
+    return action(
+      this,
+      before?.configured ? "set" : "installed",
+      Boolean(!before?.configured && result?.configured),
+      before?.configured
+        ? "Session plugin already linked"
+        : "Session plugin linked (restart OpenClaw gateway to activate)",
+    );
+  },
+  async uninstall(ctx) {
+    const result = await removeOpenclawSessionPluginConfig({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
+    });
+    if (result?.removed) {
+      return action(this, "removed", true, result.openclawConfigPath);
+    }
+    if (result?.skippedReason === "openclaw-config-missing") {
+      return action(this, "skipped", false, "openclaw config not found", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    if (result?.skippedReason === "openclaw-config-unreadable") {
+      return action(
+        this,
+        "skipped",
+        false,
+        result.error ? `openclaw config unreadable: ${result.error}` : "openclaw config unreadable",
+        { skippedReason: result.skippedReason },
+      );
+    }
+    return action(this, "unchanged", false, "no change");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}

package/src/lib/integrations/opencode.js

@@ -0,0 +1,86 @@
+const { isOpencodePluginInstalled, upsertOpencodePlugin, removeOpencodePlugin } = require("../opencode-config");
+const { isDir } = require("./utils");
+
+module.exports = {
+  name: "opencode",
+  summaryLabel: "Opencode Plugin",
+  statusLabel: "Opencode plugin",
+  async probe(ctx) {
+    const hasConfigDir = await isDir(ctx.opencode.configDir);
+    if (!hasConfigDir) {
+      return baseProbe(this, {
+        status: "not_installed",
+        detail: "Config not found",
+        initPreviewStatus: "updated",
+        initPreviewDetail: "Will install plugin",
+      });
+    }
+    const configured = await isOpencodePluginInstalled({ configDir: ctx.opencode.configDir });
+    return baseProbe(this, {
+      status: configured ? "ready" : "drifted",
+      detail: configured ? "Plugin installed" : "Run vibeusage init to reconcile plugin",
+      configured,
+    });
+  },
+  async install(ctx) {
+    const result = await upsertOpencodePlugin({
+      configDir: ctx.opencode.configDir,
+      notifyPath: ctx.notifyPath,
+    });
+    if (result?.skippedReason === "config-missing") {
+      return action(this, "skipped", false, "Config not found");
+    }
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Plugin installed" : "Plugin already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isDir(ctx.opencode.configDir))) {
+      return action(this, "skipped", false, "config dir not found");
+    }
+    const result = await removeOpencodePlugin({ configDir: ctx.opencode.configDir });
+    if (result.removed) {
+      return action(this, "removed", true, ctx.opencode.configDir);
+    }
+    if (result.skippedReason === "plugin-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    if (result.skippedReason === "unexpected-content") {
+      return action(this, "skipped", false, "unexpected content", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "config dir not found");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}

package/src/lib/integrations/utils.js

@@ -0,0 +1,39 @@
+const fs = require("node:fs/promises");
+
+async function isFile(targetPath) {
+  try {
+    const stat = await fs.stat(targetPath);
+    return stat.isFile();
+  } catch (_err) {
+    return false;
+  }
+}
+
+async function isDir(targetPath) {
+  try {
+    const stat = await fs.stat(targetPath);
+    return stat.isDirectory();
+  } catch (_err) {
+    return false;
+  }
+}
+
+function arraysEqual(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right)) return false;
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i += 1) {
+    if (String(left[i]) !== String(right[i])) return false;
+  }
+  return true;
+}
+
+function findIntegration(results, name) {
+  return Array.isArray(results) ? results.find((entry) => entry?.name === name) || null : null;
+}
+
+module.exports = {
+  isFile,
+  isDir,
+  arraysEqual,
+  findIntegration,
+};

package/src/lib/opencode-sqlite.js

@@ -0,0 +1,113 @@
+const fs = require("node:fs/promises");
+const cp = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execFileAsync = promisify(cp.execFile);
+
+function buildMessageQuery(lastTimeCreated) {
+  const since = Number.isFinite(lastTimeCreated) ? Math.max(0, Math.trunc(lastTimeCreated)) : 0;
+  return [
+    "SELECT json_object(",
+    "'id', m.id,",
+    "'session_id', m.session_id,",
+    "'time_created', m.time_created,",
+    "'role', json_extract(m.data, '$.role'),",
+    "'project_worktree', p.worktree,",
+    "'data', m.data",
+    ")",
+    "FROM message m",
+    "LEFT JOIN session s ON s.id = m.session_id",
+    "LEFT JOIN project p ON p.id = s.project_id",
+    `WHERE m.time_created >= ${since}`,
+    "ORDER BY m.time_created ASC;",
+  ].join(" ");
+}
+
+function parseMessageRows(stdout) {
+  const lines = String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const rows = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (!parsed || typeof parsed !== "object") continue;
+      rows.push(parsed);
+    } catch (_) {}
+  }
+  return rows;
+}
+
+function normalizeErrorCode(error) {
+  return typeof error?.code === "string" && error.code.trim() ? error.code.trim() : null;
+}
+
+async function readOpencodeSqliteRows({
+  dbPath,
+  lastTimeCreated = 0,
+  expectedInode = 0,
+  statFn = fs.stat,
+  execFileFn = execFileAsync,
+}) {
+  const checkedAt = new Date().toISOString();
+  const st = await statFn(dbPath).catch(() => null);
+  if (!st || !st.isFile()) {
+    return {
+      status: "missing-db",
+      checkedAt,
+      rows: [],
+      inode: 0,
+      cursorReset: false,
+      errorCode: null,
+    };
+  }
+
+  try {
+    const inode = Number.isFinite(st.ino) ? st.ino : 0;
+    const effectiveLastTimeCreated =
+      expectedInode && inode && expectedInode !== inode ? 0 : lastTimeCreated;
+    const { stdout } = await execFileFn(
+      "sqlite3",
+      ["-readonly", dbPath, buildMessageQuery(effectiveLastTimeCreated)],
+      { maxBuffer: 64 * 1024 * 1024 },
+    );
+    return {
+      status: "ok",
+      checkedAt,
+      rows: parseMessageRows(stdout),
+      inode,
+      cursorReset: Boolean(expectedInode && inode && expectedInode !== inode),
+      errorCode: null,
+    };
+  } catch (error) {
+    const errorCode = normalizeErrorCode(error);
+    if (error && error.code === "ENOENT") {
+      return {
+        status: "missing-sqlite3",
+        checkedAt,
+        rows: [],
+        inode: Number.isFinite(st.ino) ? st.ino : 0,
+        cursorReset: false,
+        error,
+        errorCode,
+      };
+    }
+    return {
+      status: "query-failed",
+      checkedAt,
+      rows: [],
+      inode: Number.isFinite(st.ino) ? st.ino : 0,
+      cursorReset: false,
+      error,
+      errorCode,
+    };
+  }
+}
+
+module.exports = {
+  buildMessageQuery,
+  parseMessageRows,
+  readOpencodeSqliteRows,
+};

package/src/lib/opencode-usage-audit.js

@@ -32,13 +32,14 @@ function addTotals(target, delta) {
 
 async function buildLocalHourlyTotals({ storageDir, source = "opencode" }) {
   const messageFiles = await listOpencodeMessageFiles(storageDir);
+  const opencodeDbPath = path.resolve(storageDir, "..", "opencode.db");
   const queuePath = path.join(
     os.tmpdir(),
     `vibeusage-opencode-audit-${process.pid}-${Date.now()}.jsonl`,
   );
-  const cursors = { version: 1, files: {}, hourly: null, opencode: null };
+  const cursors = { version: 1, files: {}, hourly: null, opencode: null, opencodeSqlite: null };
 
-  await parseOpencodeIncremental({ messageFiles, cursors, queuePath, source });
+  await parseOpencodeIncremental({ messageFiles, opencodeDbPath, cursors, queuePath, source });
   await fs.rm(queuePath, { force: true }).catch(() => {});
 
   const byHour = new Map();