@basou/cli 0.7.0 → 0.8.0

package/dist/index.js

@@ -1343,6 +1343,7 @@ import {
   importSessionFromJson,
   readManifest as readManifest3,
   readSessionYaml,
+  reimportPreservingId,
   resolveRepositoryRoot as resolveRepositoryRoot6,
   SessionImportPayloadSchema
 } from "@basou/core";
@@ -1418,10 +1419,15 @@ async function doRunImportClaudeCode(options, ctx) {
     const externalId = basename(file, ".jsonl");
     return {
       externalId,
-      toPayload: async () => claudeTranscriptToImportPayload(await readJsonlRecords(file), {
-        workspaceId: manifest.workspace.id,
-        externalId
-      })
+      sourcePath: file,
+      toPayload: async () => {
+        const { records, sizeBytes } = await readJsonlRecords(file);
+        return claudeTranscriptToImportPayload(records, {
+          workspaceId: manifest.workspace.id,
+          externalId,
+          sourceSizeBytes: sizeBytes
+        });
+      }
     };
   });
   await importDerivedSessions(paths, manifest, options, CLAUDE_IMPORT_SOURCE, candidates);
@@ -1439,10 +1445,15 @@ async function doRunImportCodex(options, ctx) {
   const rollouts = await discoverCodexRollouts(sessionsRoot, projectPaths, options);
   const candidates = rollouts.map(({ file, externalId }) => ({
     externalId,
-    toPayload: async () => codexRolloutToImportPayload(await readJsonlRecords(file), {
-      workspaceId: manifest.workspace.id,
-      externalId
-    })
+    sourcePath: file,
+    toPayload: async () => {
+      const { records, sizeBytes } = await readJsonlRecords(file);
+      return codexRolloutToImportPayload(records, {
+        workspaceId: manifest.workspace.id,
+        externalId,
+        sourceSizeBytes: sizeBytes
+      });
+    }
   }));
   await importDerivedSessions(paths, manifest, options, CODEX_IMPORT_SOURCE, candidates);
 }
@@ -1466,41 +1477,76 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
   const existingByExternalId = await loadExistingByExternalId(paths, sourceKind);
   const seenThisRun = /* @__PURE__ */ new Set();
   const results = [];
-  let skippedNoAction = 0;
-  let skippedExisting = 0;
-  let replaced = 0;
+  const counts = {
+    skippedNoAction: 0,
+    skippedExisting: 0,
+    replaced: 0,
+    reimported: 0,
+    skippedLegacy: 0,
+    skippedDecreased: 0,
+    skippedDuplicate: 0
+  };
   let sanitizedPaths = 0;
-  for (const { externalId, toPayload } of candidates) {
+  const validate = (payload) => {
+    if (payload === null) return null;
+    const parsed = SessionImportPayloadSchema.safeParse(payload);
+    if (!parsed.success) {
+      throw new Error("Invalid import payload", { cause: parsed.error });
+    }
+    if (parsed.data.schema_version !== "0.1.0") {
+      throw new Error(`Unsupported import schema_version: ${parsed.data.schema_version}`);
+    }
+    return parsed.data;
+  };
+  for (const { externalId, sourcePath, toPayload } of candidates) {
     if (seenThisRun.has(externalId)) {
-      skippedExisting++;
+      counts.skippedExisting++;
       continue;
     }
-    const priorSessionIds = existingByExternalId.get(externalId) ?? [];
-    if (priorSessionIds.length > 0 && options.force !== true) {
-      skippedExisting++;
+    const priors = existingByExternalId.get(externalId) ?? [];
+    if (priors.length > 0 && options.force !== true) {
+      const prior = await classifyReimport(priors, sourcePath, externalId, counts);
+      if (prior === null) continue;
+      const payload2 = validate(await toPayload());
+      if (payload2 === null) {
+        counts.skippedNoAction++;
+        continue;
+      }
+      const readSize = payload2.session.source.source_size_bytes;
+      if (prior.sourceSizeBytes !== void 0 && readSize !== void 0 && readSize <= prior.sourceSizeBytes) {
+        console.error(
+          `Import: ${externalId} source changed during read (now ${readSize} <= ${prior.sourceSizeBytes} bytes); re-import skipped`
+        );
+        counts.skippedDecreased++;
+        continue;
+      }
+      const outcome = await reimportPreservingId(paths, manifest, prior.sessionId, payload2, {
+        dryRun: options.dryRun === true
+      });
+      if (outcome.status === "skipped") {
+        const detail = outcome.reason === "prior_events_unreadable" ? "prior events.jsonl has unreadable lines" : "source changed in a non-append way (derived events would be dropped)";
+        console.error(`Import: ${externalId} ${detail}; re-import skipped`);
+        counts.skippedNoAction++;
+        continue;
+      }
+      counts.reimported++;
+      seenThisRun.add(externalId);
       continue;
     }
-    const payload = await toPayload();
+    const payload = validate(await toPayload());
     if (payload === null) {
-      skippedNoAction++;
+      counts.skippedNoAction++;
       continue;
     }
-    const parsed = SessionImportPayloadSchema.safeParse(payload);
-    if (!parsed.success) {
-      throw new Error("Invalid import payload", { cause: parsed.error });
-    }
-    if (parsed.data.schema_version !== "0.1.0") {
-      throw new Error(`Unsupported import schema_version: ${parsed.data.schema_version}`);
-    }
-    if (priorSessionIds.length > 0 && options.force === true) {
+    if (priors.length > 0 && options.force === true) {
       if (options.dryRun !== true) {
-        for (const sid of priorSessionIds) {
-          await rm(join3(paths.sessions, sid), { recursive: true, force: true });
+        for (const { sessionId } of priors) {
+          await rm(join3(paths.sessions, sessionId), { recursive: true, force: true });
         }
       }
-      replaced++;
+      counts.replaced++;
     }
-    const result = await importSessionFromJson(paths, manifest, parsed.data, {
+    const result = await importSessionFromJson(paths, manifest, payload, {
       dryRun: options.dryRun === true
     });
     results.push(result);
@@ -1510,17 +1556,52 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
   if (sanitizedPaths > 0) {
     console.error(`Imported sessions: ${sanitizedPaths} path(s) sanitized`);
   }
-  printImportResult(options, results, { skippedNoAction, skippedExisting, replaced });
+  printImportResult(options, results, counts);
+}
+async function classifyReimport(priors, sourcePath, externalId, counts) {
+  if (priors.length > 1) {
+    console.error(
+      `Import: ${externalId} has ${priors.length} prior sessions; re-import skipped (use --force)`
+    );
+    counts.skippedDuplicate++;
+    return null;
+  }
+  const prior = priors[0];
+  if (prior === void 0) {
+    counts.skippedExisting++;
+    return null;
+  }
+  const currentSize = await statSize(sourcePath);
+  if (currentSize === void 0) {
+    counts.skippedExisting++;
+    return null;
+  }
+  if (prior.sourceSizeBytes === void 0) {
+    counts.skippedLegacy++;
+    return null;
+  }
+  if (currentSize === prior.sourceSizeBytes) {
+    counts.skippedExisting++;
+    return null;
+  }
+  if (currentSize < prior.sourceSizeBytes) {
+    console.error(
+      `Import: ${externalId} source shrank (${currentSize} < ${prior.sourceSizeBytes} bytes); re-import skipped (use --force to replace)`
+    );
+    counts.skippedDecreased++;
+    return null;
+  }
+  return prior;
 }
 function encodeProjectDir(projectPath) {
   return projectPath.replaceAll("/", "-");
 }
 async function loadExistingByExternalId(paths, sourceKind) {
   const byExternalId = /* @__PURE__ */ new Map();
-  const add = (externalId, sessionId) => {
+  const add = (externalId, prior) => {
     const list = byExternalId.get(externalId);
-    if (list === void 0) byExternalId.set(externalId, [sessionId]);
-    else list.push(sessionId);
+    if (list === void 0) byExternalId.set(externalId, [prior]);
+    else list.push(prior);
   };
   let sessionIds;
   try {
@@ -1536,14 +1617,16 @@ async function loadExistingByExternalId(paths, sourceKind) {
       continue;
     }
     if (session.session.source.kind !== sourceKind) continue;
+    const sourceSizeBytes = session.session.source.source_size_bytes;
+    const prior = sourceSizeBytes !== void 0 ? { sessionId, sourceSizeBytes } : { sessionId };
     const ext = session.session.source.external_id;
     if (typeof ext === "string" && ext.length > 0) {
-      add(ext, sessionId);
+      add(ext, prior);
       continue;
     }
     const label = session.session.label;
     const match = typeof label === "string" ? label.match(/^claude-code import (\S+)$/) : null;
-    if (match?.[1] !== void 0) add(match[1], sessionId);
+    if (match?.[1] !== void 0) add(match[1], prior);
   }
   return byExternalId;
 }
@@ -1589,6 +1672,14 @@ async function pathExists(file) {
     throw error;
   }
 }
+async function statSize(file) {
+  try {
+    return (await stat(file)).size;
+  } catch (error) {
+    if (findErrorCode5(error, "ENOENT")) return void 0;
+    throw error;
+  }
+}
 async function discoverCodexRollouts(sessionsRoot, projectPaths, options) {
   const projectSet = new Set(projectPaths);
   const files = await findRolloutFiles(sessionsRoot);
@@ -1667,9 +1758,9 @@ async function readFirstLine(file) {
   }
 }
 async function readJsonlRecords(file) {
-  let body;
+  let buffer;
   try {
-    body = await readFile(file, "utf8");
+    buffer = await readFile(file);
   } catch (error) {
     if (findErrorCode5(error, "ENOENT")) {
       throw new Error("Source log not found", { cause: error });
@@ -1680,7 +1771,7 @@ async function readJsonlRecords(file) {
     throw new Error("Failed to read source log", { cause: error });
   }
   const records = [];
-  for (const line of body.split("\n")) {
+  for (const line of buffer.toString("utf8").split("\n")) {
     const trimmed = line.trim();
     if (trimmed.length === 0) continue;
     try {
@@ -1691,7 +1782,7 @@ async function readJsonlRecords(file) {
     } catch {
     }
   }
-  return records;
+  return { records, sizeBytes: buffer.length };
 }
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1699,7 +1790,15 @@ function isObject(value) {
 function printImportResult(options, results, counts) {
   const isDry = options.dryRun === true;
   const eventTotal = results.reduce((sum, r) => sum + r.eventCount, 0);
-  const { skippedNoAction, skippedExisting, replaced } = counts;
+  const {
+    skippedNoAction,
+    skippedExisting,
+    replaced,
+    reimported,
+    skippedLegacy,
+    skippedDecreased,
+    skippedDuplicate
+  } = counts;
   if (options.json === true) {
     console.log(
       JSON.stringify({
@@ -1711,8 +1810,12 @@ function printImportResult(options, results, counts) {
         })),
         imported_count: results.length,
         replaced_count: replaced,
+        reimported_count: reimported,
         skipped_no_action: skippedNoAction,
         skipped_already_imported: skippedExisting,
+        skipped_legacy_untracked: skippedLegacy,
+        skipped_decreased: skippedDecreased,
+        skipped_duplicate: skippedDuplicate,
         event_total: eventTotal,
         dry_run: isDry
       })
@@ -1722,20 +1825,36 @@ function printImportResult(options, results, counts) {
   const skipParts = [];
   if (skippedNoAction > 0) skipParts.push(`${skippedNoAction} with no actions`);
   if (skippedExisting > 0) skipParts.push(`${skippedExisting} already imported`);
+  if (skippedLegacy > 0) skipParts.push(`${skippedLegacy} legacy (untracked size)`);
+  if (skippedDecreased > 0) skipParts.push(`${skippedDecreased} shrank`);
+  if (skippedDuplicate > 0) skipParts.push(`${skippedDuplicate} duplicated`);
   const skipSuffix = skipParts.length > 0 ? `; skipped ${skipParts.join(", ")}` : "";
   const eventsPart = replaced > 0 ? `${eventTotal} events, ${replaced} replaced` : `${eventTotal} events`;
-  if (results.length === 0) {
+  if (isDry) {
+    const parts = [];
+    if (results.length > 0) parts.push(`import ${results.length} session(s) (${eventsPart})`);
+    if (reimported > 0) parts.push(`re-import ${reimported} changed session(s)`);
+    const head = parts.length > 0 ? `Dry run: would ${parts.join(", ")}` : "Dry run: no changes";
+    console.log(`${head}${skipSuffix}`);
+    return;
+  }
+  if (results.length === 0 && reimported === 0) {
     console.log(
       skipParts.length > 0 ? `No new sessions imported (skipped ${skipParts.join(", ")})` : "No transcripts found to import"
     );
     return;
   }
-  if (isDry) {
-    console.log(`Dry run: would import ${results.length} session(s) (${eventsPart})${skipSuffix}`);
-    return;
+  const segments = [];
+  if (results.length > 0) {
+    const single = results.length === 1 && results[0] !== void 0 ? ` (${shortId2(results[0].sessionId)})` : "";
+    segments.push(`Imported ${results.length} session(s)${single} (${eventsPart})`);
+  }
+  if (reimported > 0) {
+    segments.push(
+      `${results.length > 0 ? "re-imported" : "Re-imported"} ${reimported} changed session(s)`
+    );
   }
-  const single = results.length === 1 && results[0] !== void 0 ? ` (${shortId2(results[0].sessionId)})` : "";
-  console.log(`Imported ${results.length} session(s)${single} (${eventsPart})${skipSuffix}`);
+  console.log(`${segments.join(", ")}${skipSuffix}`);
 }
 function shortId2(id) {
   if (id.startsWith(SES_PREFIX2)) {
@@ -1908,8 +2027,10 @@ async function runImport(adapter, fn) {
       status: "ran",
       importedCount: readCount(json.imported_count),
       replacedCount: readCount(json.replaced_count),
+      reimportedCount: readCount(json.reimported_count),
       skippedNoAction: readCount(json.skipped_no_action),
       skippedAlreadyImported: readCount(json.skipped_already_imported),
+      skippedLegacyUntracked: readCount(json.skipped_legacy_untracked),
       eventTotal: readCount(json.event_total),
       dryRun: json.dry_run === true
     };
@@ -2030,11 +2151,13 @@ function scansEqual(a, b) {
   }
   return true;
 }
-function importedCount(outcome) {
-  return outcome.status === "ran" ? outcome.importedCount : 0;
+function changedCount(outcome) {
+  return outcome.status === "ran" ? outcome.importedCount + outcome.reimportedCount + outcome.replacedCount : 0;
 }
 function describeOutcome(outcome) {
-  return outcome.status === "ran" ? `${outcome.adapter} +${outcome.importedCount}` : `${outcome.adapter} skipped`;
+  if (outcome.status !== "ran") return `${outcome.adapter} skipped`;
+  const reimported = outcome.reimportedCount > 0 ? ` ~${outcome.reimportedCount}` : "";
+  return `${outcome.adapter} +${outcome.importedCount}${reimported}`;
 }
 function hms(date) {
   return date.toISOString().slice(11, 19);
@@ -2042,7 +2165,7 @@ function hms(date) {
 async function runImports(deps) {
   const claude = await importClaudeCode(deps.importOptions, deps.ctx);
   const codex = await importCodex(deps.importOptions, deps.ctx);
-  return { claude, codex, imported: importedCount(claude) + importedCount(codex) };
+  return { claude, codex, changed: changedCount(claude) + changedCount(codex) };
 }
 async function regenerate(deps) {
   const nowIso = deps.now().toISOString();
@@ -2074,8 +2197,8 @@ async function runRefreshWatch(deps) {
     try {
       const current = await scanSourceLogs(roots);
       if (scansEqual(current, lastScan) && !scansEqual(current, importedScan)) {
-        const { claude, codex, imported } = await runImports(deps);
-        if (imported > 0) pendingRegen = true;
+        const { claude, codex, changed } = await runImports(deps);
+        if (changed > 0) pendingRegen = true;
         if (pendingRegen) {
           const sessions = await regenerate(deps);
           pendingRegen = false;
@@ -2214,9 +2337,11 @@ function describeImport(outcome) {
   }
   const verb = outcome.dryRun ? "would import" : "imported";
   const parts = [`${outcome.importedCount} session(s)`, `${outcome.eventTotal} events`];
+  if (outcome.reimportedCount > 0) parts.push(`${outcome.reimportedCount} re-imported`);
   if (outcome.replacedCount > 0) parts.push(`${outcome.replacedCount} replaced`);
   if (outcome.skippedAlreadyImported > 0)
     parts.push(`${outcome.skippedAlreadyImported} already imported`);
+  if (outcome.skippedLegacyUntracked > 0) parts.push(`${outcome.skippedLegacyUntracked} legacy`);
   return `${outcome.adapter}: ${verb} ${parts.join(", ")}`;
 }
 function printRefreshSummary(result) {