@yhong91/vibetime 0.1.3 → 0.1.5

package/bin/vibetime.mjs

@@ -1195,7 +1195,7 @@ function countTextLines(text) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.3" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.5" : "0.1.1";
 var DEFAULT_API_URL = "http://121.196.224.82:3001";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -3024,6 +3024,7 @@ function createClaudeCoworkAdapter() {
 // src/adapters/codebuddy.ts
 import { readFile as readFile5, readdir as readdir4 } from "node:fs/promises";
 import path8 from "node:path";
+var ENDPOINT_MODEL_ID_RE = /^(?:ep|endpoint)-/i;
 async function parseCodebuddyTraceFile(filePath, options) {
   const text = await readFile5(filePath, "utf8");
   const sourcePathHash = `sha256:${createStableHash(filePath)}`;
@@ -3051,7 +3052,7 @@ async function parseCodebuddyTraceFile(filePath, options) {
   }
   const project = cwd ? path8.basename(cwd) : void 0;
   const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
-  const model = trace.modelInfo?.models?.[0];
+  const model = resolveCodebuddyModel(trace, spans);
   const baseEvent = (event) => ({
     schemaVersion: AGENT_TIME_SCHEMA_VERSION,
     source: "codebuddy",
@@ -3314,6 +3315,87 @@ async function parseCodebuddyTraceFile(filePath, options) {
   }
   return events.filter((event) => validateCanonicalEvent(event).valid);
 }
+function resolveCodebuddyModel(trace, spans) {
+  const spanModel = modelFromSpans(spans);
+  if (spanModel) {
+    return spanModel;
+  }
+  const metadataModel = findHumanModelName(trace.metadata);
+  if (metadataModel) {
+    return metadataModel;
+  }
+  for (const candidate of trace.modelInfo?.models || []) {
+    const normalized = normalizeModelCandidate(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+function modelFromSpans(spans) {
+  for (const span of spans) {
+    const parsedOutput = parseEmbeddedJson(span.toolOutput);
+    const outputModel = findHumanModelName(parsedOutput);
+    if (outputModel) {
+      return outputModel;
+    }
+    const parsedInput = parseEmbeddedJson(span.toolInput);
+    const inputModel = findHumanModelName(parsedInput);
+    if (inputModel) {
+      return inputModel;
+    }
+  }
+  return void 0;
+}
+function parseEmbeddedJson(value) {
+  if (!value?.trim()) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function findHumanModelName(value) {
+  const queue = [value];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (Array.isArray(current)) {
+      queue.push(...current);
+      continue;
+    }
+    if (!isPlainObject(current)) {
+      continue;
+    }
+    const preferred = [
+      stringField(current, "requestModelName"),
+      stringField(current, "modelName"),
+      stringField(current, "model_name"),
+      stringField(current, "model"),
+      stringField(current, "requestModelId"),
+      stringField(current, "modelId")
+    ];
+    for (const candidate of preferred) {
+      const normalized = normalizeModelCandidate(candidate);
+      if (normalized) {
+        return normalized;
+      }
+    }
+    queue.push(...Object.values(current));
+  }
+  return void 0;
+}
+function normalizeModelCandidate(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed || ENDPOINT_MODEL_ID_RE.test(trimmed)) {
+    return void 0;
+  }
+  return trimmed;
+}
 function modelUsageFromTrace(trace, generationIndex, totalGenerations) {
   const info = trace.modelInfo;
   if (!info || !info.totalInputTokens && !info.totalOutputTokens && !trace.totalTokens) {
@@ -8072,7 +8154,7 @@ async function deleteMachine(remote, id) {
 }
 
 // src/lib/types.ts
-var BACKFILL_STATE_SCHEMA_VERSION = 4;
+var BACKFILL_STATE_SCHEMA_VERSION = 5;
 
 // src/cli.ts
 function createRegistry() {
@@ -8593,10 +8675,12 @@ async function importBackfillPlan(plan, options, ctx, registry) {
     return 1;
   }
   const sourceDefs = registry.all().filter((a) => supportedSources.has(a.id) && (source === "all" || a.id === source)).map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home, ctx.env) }));
+  const remote = resolveRemoteFromOptions(options, ctx);
+  const remoteKey = backfillRemoteKey(remote?.baseUrl ?? DEFAULT_API_URL);
   if (options.force) {
-    await purgeForcedSources(sourceDefs, home, options, ctx);
+    await purgeForcedSources(sourceDefs, home, remoteKey, options, ctx);
   }
-  const incrementalState = shouldUseIncrementalBackfill(options) ? await readBackfillIncrementalState(home, ctx) : void 0;
+  const incrementalState = shouldUseIncrementalBackfill(options) ? await readBackfillIncrementalState(home, remoteKey, ctx) : void 0;
   if (!options.json) {
     write(ctx.stdout, `importRun ${plan.importRun.importRunId}
 `);
@@ -8624,13 +8708,15 @@ async function importBackfillPlan(plan, options, ctx, registry) {
 `);
   }
   if (counts.failed === 0 && counts.conflicts === 0 && incrementalState) {
-    await updateBackfillIncrementalState(home, incrementalState, selectedFilesBySource);
+    await updateBackfillIncrementalState(home, remoteKey, incrementalState, selectedFilesBySource);
   }
   return counts.failed > 0 || counts.conflicts > 0 && !options["skip-conflicts"] ? 1 : 0;
 }
-async function purgeForcedSources(sourceDefs, home, options, ctx) {
+async function purgeForcedSources(sourceDefs, home, remoteKey, options, ctx) {
   try {
-    await rm(backfillIncrementalStatePath(home), { force: true });
+    const file = await readBackfillIncrementalStateFile(home);
+    delete file.remotes[remoteKey];
+    await writeBackfillIncrementalStateFile(home, file);
   } catch (error) {
     debug(ctx, `Failed to clear backfill watermark: ${error.message}
 `);
@@ -8826,36 +8912,75 @@ function syncLocalTriggerStatePath(home) {
 function syncLocalTriggerLockPath(home) {
   return path18.join(home, ".vibetime", "sync-local-trigger.lock");
 }
-async function readBackfillIncrementalState(home, ctx) {
+function backfillRemoteKey(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    return `${url.protocol}//${url.host}${url.pathname.replace(/\/+$/, "")}`;
+  } catch {
+    return baseUrl.replace(/\/+$/, "");
+  }
+}
+function sanitizeBackfillSources(raw) {
+  const sources = {};
+  if (!isPlainObject(raw)) {
+    return sources;
+  }
+  for (const source of BACKFILL_SOURCE_IDS) {
+    const item = raw[source];
+    if (isPlainObject(item) && typeof item.watermarkTs === "string" && !Number.isNaN(Date.parse(item.watermarkTs))) {
+      sources[source] = { watermarkTs: item.watermarkTs };
+    }
+  }
+  return sources;
+}
+async function readBackfillIncrementalStateFile(home, ctx) {
+  const empty = { version: BACKFILL_STATE_SCHEMA_VERSION, remotes: {} };
   const statePath = backfillIncrementalStatePath(home);
   const state = await readJsonIfExists(statePath);
   if (state === null) {
-    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+    return empty;
   }
-  if (!isPlainObject(state) || !isPlainObject(state.sources)) {
+  if (!isPlainObject(state)) {
     if (ctx) {
       debug(ctx, `backfill-state malformed at ${statePath}; ignoring watermarks
 `);
     }
-    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+    return empty;
   }
   if (state.version !== BACKFILL_STATE_SCHEMA_VERSION) {
     if (ctx) {
       debug(ctx, `backfill-state version ${String(state.version)} at ${statePath} differs from current v${BACKFILL_STATE_SCHEMA_VERSION}; dropping watermarks so the next sync re-imports under the new parser
 `);
     }
-    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+    return empty;
   }
-  const sources = {};
-  for (const source of BACKFILL_SOURCE_IDS) {
-    const item = state.sources[source];
-    if (isPlainObject(item) && typeof item.watermarkTs === "string" && !Number.isNaN(Date.parse(item.watermarkTs))) {
-      sources[source] = { watermarkTs: item.watermarkTs };
+  if (!isPlainObject(state.remotes)) {
+    if (ctx) {
+      debug(ctx, `backfill-state malformed at ${statePath}; ignoring watermarks
+`);
+    }
+    return empty;
+  }
+  const remotes = {};
+  for (const [remoteKey, entry] of Object.entries(state.remotes)) {
+    if (!isPlainObject(entry)) {
+      continue;
     }
+    remotes[remoteKey] = { sources: sanitizeBackfillSources(entry.sources) };
   }
-  return { version: BACKFILL_STATE_SCHEMA_VERSION, sources };
+  return { version: BACKFILL_STATE_SCHEMA_VERSION, remotes };
 }
-async function updateBackfillIncrementalState(home, state, selectedFilesBySource) {
+async function writeBackfillIncrementalStateFile(home, file) {
+  const statePath = backfillIncrementalStatePath(home);
+  await mkdir4(path18.dirname(statePath), { recursive: true });
+  await writeFile3(statePath, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+}
+async function readBackfillIncrementalState(home, remoteKey, ctx) {
+  const file = await readBackfillIncrementalStateFile(home, ctx);
+  return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: file.remotes[remoteKey]?.sources ?? {} };
+}
+async function updateBackfillIncrementalState(home, remoteKey, state, selectedFilesBySource) {
   for (const [source, files] of selectedFilesBySource.entries()) {
     const latest = maxTimestamp(files.map((f) => f.modifiedAt));
     if (!latest) {
@@ -8863,10 +8988,9 @@ async function updateBackfillIncrementalState(home, state, selectedFilesBySource
     }
     state.sources[source] = { watermarkTs: latest };
   }
-  const statePath = backfillIncrementalStatePath(home);
-  await mkdir4(path18.dirname(statePath), { recursive: true });
-  await writeFile3(statePath, `${JSON.stringify(state, null, 2)}
-`, "utf8");
+  const file = await readBackfillIncrementalStateFile(home);
+  file.remotes[remoteKey] = { sources: state.sources };
+  await writeBackfillIncrementalStateFile(home, file);
 }
 async function readSyncLocalTriggerState(statePath) {
   let state;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yhong91/vibetime",
   "type": "module",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "vibetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to vibetime.",
   "license": "MIT",
   "publishConfig": {