@remnic/core 9.69.39 → 9.69.41

package/dist/{chunk-5HYUUFMQ.js → chunk-XCPNH2MG.js}

@@ -9,6 +9,9 @@ import {
   coerceBooleanLike,
   coerceNumber
 } from "./chunk-PQVCH2AE.js";
+import {
+  expandTildePath
+} from "./chunk-6KH5NLQS.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -137,6 +140,214 @@ function isoWeekNumber(date) {
   return String(weekNo).padStart(2, "0");
 }
 
+// src/activity/vault-publish.ts
+import { createHash, randomBytes } from "crypto";
+import { readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import path2 from "path";
+function applyManagedRegion(fileText, opts) {
+  if (opts.strategy === "heading") return applyHeadingRegion(fileText, opts.name, opts.content);
+  const startMarker = `<!-- remnic:${opts.name}:start -->`;
+  const endMarker = `<!-- remnic:${opts.name}:end -->`;
+  const rows = fileLines(fileText);
+  let startRow;
+  let endRow;
+  for (const row of rows) {
+    if (row.fenced) continue;
+    const trimmed = row.line.trim();
+    if (startRow === void 0) {
+      if (trimmed === startMarker) startRow = row;
+    } else if (endRow === void 0 && trimmed === endMarker) {
+      endRow = row;
+      break;
+    }
+  }
+  if (startRow === void 0 || endRow === void 0) {
+    return { ok: false, reason: "no_marker", text: fileText };
+  }
+  const { body, eol } = ownedBody(fileText, opts.content);
+  return {
+    ok: true,
+    text: `${fileText.slice(0, startRow.start + startRow.line.length)}${eol}${body}${eol}${fileText.slice(endRow.start)}`
+  };
+}
+function applyHeadingRegion(fileText, name, content) {
+  const wanted = name.trim();
+  const rows = fileLines(fileText);
+  const hits = [];
+  for (const row of rows) {
+    if (row.fenced) continue;
+    const heading = parseAtxHeading(row.line);
+    if (heading && heading.text === wanted) {
+      hits.push({ line: row.number, level: heading.level, next: row.next });
+    }
+  }
+  if (hits.length === 0) return { ok: false, reason: "no_heading", text: fileText };
+  if (hits.length > 1) {
+    return { ok: false, reason: "duplicate_heading", lines: hits.map((hit2) => hit2.line), text: fileText };
+  }
+  const hit = hits[0];
+  let sectionEnd = fileText.length;
+  for (const row of rows) {
+    if (row.start < hit.next || row.fenced) continue;
+    const heading = parseAtxHeading(row.line);
+    if (heading && heading.level <= hit.level) {
+      sectionEnd = row.start;
+      break;
+    }
+  }
+  const { body, eol } = ownedBody(fileText, demoteOwnedHeadings(content, hit.level));
+  const prefix = hit.next === fileText.length && !fileText.endsWith("\n") && !fileText.endsWith("\r") ? `${fileText}${eol}` : fileText.slice(0, hit.next);
+  return { ok: true, text: `${prefix}${body}${eol}${fileText.slice(sectionEnd)}` };
+}
+function demoteOwnedHeadings(content, owningLevel) {
+  const rows = fileLines(content);
+  let out = "";
+  let cursor = 0;
+  for (const row of rows) {
+    const heading = row.fenced ? null : parseAtxHeading(row.line);
+    if (heading === null) continue;
+    const level = Math.min(owningLevel + heading.level, 6);
+    const replacement = level > owningLevel ? `${"#".repeat(level)} ${heading.text}` : `**${heading.text}**`;
+    out += content.slice(cursor, row.start) + replacement;
+    cursor = row.start + row.line.length;
+  }
+  return out + content.slice(cursor);
+}
+function ownedBody(fileText, content) {
+  const eol = fileText.includes("\r\n") ? "\r\n" : "\n";
+  let body = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\r\n") body = body.replace(/\n/g, "\r\n");
+  if (body.endsWith(eol)) body = body.slice(0, -eol.length);
+  return { body, eol };
+}
+function fileLines(fileText) {
+  const rows = [];
+  let start = 0;
+  let number = 1;
+  let fence = null;
+  while (start < fileText.length) {
+    let i = start;
+    while (i < fileText.length && fileText[i] !== "\n" && fileText[i] !== "\r") i++;
+    let next = i;
+    if (fileText[i] === "\r" && fileText[i + 1] === "\n") next = i + 2;
+    else if (fileText[i] === "\n" || fileText[i] === "\r") next = i + 1;
+    else next = fileText.length;
+    const line = fileText.slice(start, i);
+    const indentedCode = indentColumn(line) >= 4;
+    const run = indentedCode ? null : fenceRun(line);
+    let fenced;
+    if (fence === null) {
+      if (run !== null && !(run.char === "`" && run.info.includes("`"))) {
+        fence = { char: run.char, len: run.len };
+      }
+      fenced = fence !== null || indentedCode;
+    } else {
+      fenced = true;
+      if (run !== null && run.char === fence.char && run.len >= fence.len && run.info.length === 0) {
+        fence = null;
+      }
+    }
+    rows.push({ line, start, next, number, fenced });
+    number += 1;
+    start = next;
+  }
+  return rows;
+}
+function indentColumn(line) {
+  let col = 0;
+  for (let i = 0; i < line.length; i += 1) {
+    const ch = line[i];
+    if (ch === " ") col += 1;
+    else if (ch === "	") col += 4 - col % 4;
+    else break;
+  }
+  return col;
+}
+function fenceRun(line) {
+  const body = line.trimStart();
+  const char = body[0];
+  if (char !== "`" && char !== "~") return null;
+  let len = 0;
+  while (len < body.length && body[len] === char) len++;
+  if (len < 3) return null;
+  return { char, len, info: body.slice(len).trim() };
+}
+function parseAtxHeading(line) {
+  let at = 0;
+  let indent = 0;
+  while (at < line.length && (line[at] === " " || line[at] === "	")) {
+    indent += line[at] === " " ? 1 : 4 - indent % 4;
+    if (indent >= 4) return null;
+    at += 1;
+  }
+  let level = 0;
+  while (level < 6 && line[at + level] === "#") level++;
+  if (level === 0) return null;
+  const after = line[at + level];
+  if (after !== " " && after !== "	") return null;
+  let start = at + level + 1;
+  let end = line.length;
+  while (start < end && (line[start] === " " || line[start] === "	")) start++;
+  while (end > start && (line[end - 1] === " " || line[end - 1] === "	")) end--;
+  let hashEnd = end;
+  while (hashEnd > start && line[hashEnd - 1] === "#") hashEnd--;
+  if (hashEnd < end && hashEnd > start && (line[hashEnd - 1] === " " || line[end - 1] === "	")) {
+    end = hashEnd;
+    while (end > start && (line[end - 1] === " " || line[end - 1] === "	")) end--;
+  }
+  return { level, text: line.slice(start, end) };
+}
+function headingSurvivesRoundTrip(name) {
+  const parsed = parseAtxHeading(`## ${name}`);
+  return parsed !== null && parsed.text === name;
+}
+function publishVaultRegion(input) {
+  const vault = expandTildePath(input.vaultPath);
+  try {
+    if (!statSync(vault).isDirectory()) return { ok: false, reason: "not_directory" };
+  } catch {
+    return { ok: false, reason: "not_directory" };
+  }
+  if (input.relativeFile.length === 0 || path2.isAbsolute(input.relativeFile)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  const root = path2.resolve(vault);
+  const dest = path2.resolve(root, input.relativeFile);
+  const rel = path2.relative(root, dest);
+  if (rel.length === 0 || rel.startsWith("..") || path2.isAbsolute(rel)) {
+    return { ok: false, reason: "missing_file" };
+  }
+  let existing;
+  try {
+    if (!statSync(dest).isFile()) return { ok: false, reason: "missing_file" };
+    existing = readFileSync(dest, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { ok: false, reason: "missing_file" };
+    throw err;
+  }
+  const applied = applyManagedRegion(existing, {
+    strategy: "markers",
+    name: input.name,
+    content: input.content
+  });
+  if (!applied.ok) return { ok: false, reason: "no_marker" };
+  const prevHash = createHash("sha256").update(existing, "utf8").digest("hex");
+  const nextHash = createHash("sha256").update(applied.text, "utf8").digest("hex");
+  if (prevHash === nextHash) return { ok: true, status: "unchanged" };
+  const tmpPath = path2.join(path2.dirname(dest), `.remnic-vault-${randomBytes(8).toString("hex")}.tmp`);
+  writeFileSync(tmpPath, applied.text);
+  try {
+    renameSync(tmpPath, dest);
+  } catch (renameErr) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw renameErr;
+  }
+  return { ok: true, status: "updated" };
+}
+
 // src/activity/vault-region.ts
 function validateRegionName(name) {
   if (typeof name !== "string") {
@@ -145,11 +356,10 @@ function validateRegionName(name) {
   if (name.includes("\n") || name.includes("\r") || name.includes("-->") || name.includes(":")) {
     return { ok: false, error: "invalid_name" };
   }
-  const trimmed = name.trim();
-  if (trimmed.length === 0) {
+  if (name.trim() !== name || name.trim().length === 0) {
     return { ok: false, error: "invalid_name" };
   }
-  return { ok: true, name: trimmed };
+  return { ok: true, name };
 }
 
 // src/activity/timeline/analysis-failure.ts
@@ -223,17 +433,19 @@ function timelineAnalysisCompleteFromClients(input) {
           "timeline analysis local provider is not configured"
         );
       }
+      const failureDiag2 = {};
       const result2 = await localLlm.chatCompletion(messages, {
         temperature: 0,
         maxTokens: 2048,
         signal,
         operation: "timeline-analysis",
         redactProviderErrors: true,
-        model
+        model,
+        failureDiag: failureDiag2
       });
       if (result2 === null) {
         throw new TimelineAnalysisProviderError(
-          "provider_unavailable",
+          classifyAnalysisProviderError(failureDiag2.lastError),
           "timeline analysis local provider returned no completion"
         );
       }
@@ -245,17 +457,19 @@ function timelineAnalysisCompleteFromClients(input) {
         "timeline analysis remote provider is not configured"
       );
     }
+    const failureDiag = {};
     const result = await remoteLlm.chatCompletion(messages, {
       temperature: 0,
       maxTokens: 2048,
       signal,
       modelChain: { primary: `${provider}/${model}` },
       includeDefaultModelFallback: false,
-      redactProviderErrors: true
+      redactProviderErrors: true,
+      failureDiag
     });
     if (result === null) {
       throw new TimelineAnalysisProviderError(
-        "provider_unavailable",
+        classifyAnalysisProviderError(failureDiag.lastError),
         `timeline analysis provider "${provider}" is not configured`
       );
     }
@@ -669,7 +883,7 @@ function buildAnalysisRunMetadata(input) {
 }
 
 // src/activity/config.ts
-import path2 from "path";
+import path3 from "path";
 
 // src/activity/journal-heading.ts
 function normalizeJournalHeading(value) {
@@ -1009,6 +1223,19 @@ function parseTimelineVaultConfig(raw) {
   const weeklyNotePath = optionalNonEmptyString(vault.weeklyNotePath, "activity.timeline.vault.weeklyNotePath") ?? "";
   const noteTemplate = optionalNonEmptyString(vault.noteTemplate, "activity.timeline.vault.noteTemplate") ?? "";
   const insertUnderHeading = optionalNonEmptyString(vault.insertUnderHeading, "activity.timeline.vault.insertUnderHeading") ?? "";
+  if (insertUnderHeading.length > 0) {
+    const heading = normalizeJournalHeading(insertUnderHeading);
+    if (!heading.ok || heading.heading !== insertUnderHeading) {
+      throw new RangeError(
+        "activity.timeline.vault.insertUnderHeading must be a non-empty trimmed single-line heading"
+      );
+    }
+    if (!headingSurvivesRoundTrip(insertUnderHeading)) {
+      throw new RangeError(
+        "activity.timeline.vault.insertUnderHeading must survive a heading render-and-parse round trip"
+      );
+    }
+  }
   if (typeof vault.sectionStrategy !== "undefined" && typeof vault.sectionStrategy !== "string") {
     throw new TypeError("activity.timeline.vault.sectionStrategy must be a string");
   }
@@ -1017,7 +1244,7 @@ function parseTimelineVaultConfig(raw) {
     throw new RangeError('activity.timeline.vault.sectionStrategy must be one of "markers", "heading"');
   }
   const tildeRooted = vaultPath === "~" || vaultPath.startsWith("~/") || vaultPath.startsWith("~\\");
-  if (enabled && (vaultPath.trim().length === 0 || !tildeRooted && !path2.isAbsolute(vaultPath))) {
+  if (enabled && (vaultPath.trim().length === 0 || !tildeRooted && !path3.isAbsolute(vaultPath))) {
     throw new RangeError(
       `activity.timeline.vault.vaultPath must be an absolute or \`~\`-rooted path when activity.timeline.vault.enabled is true; a relative path resolves against the process working directory (got ${JSON.stringify(vaultPath)})`
     );
@@ -1047,6 +1274,15 @@ function parseTimelineVaultConfig(raw) {
     }
   }
   const publish = parseVaultPublishBlock(vault.publish, weeklyNotePath);
+  if (sectionStrategy === "heading") {
+    for (const kind of ["timeline", "standup", "weekly", "locations"]) {
+      if (!headingSurvivesRoundTrip(publish[kind].section)) {
+        throw new RangeError(
+          `activity.timeline.vault.publish.${kind}.section must survive a heading render-and-parse round trip`
+        );
+      }
+    }
+  }
   const wikilinksRaw = vault.wikilinks;
   const wikilinks = wikilinksRaw === void 0 ? { places: false, placesFolder: "Places" } : parseVaultWikilinks(wikilinksRaw);
   const propertiesRaw = vault.properties;
@@ -1059,6 +1295,14 @@ function parseTimelineVaultConfig(raw) {
     readbackRaw?.journalSection,
     "activity.timeline.vault.readback.journalSection"
   );
+  if (readbackJournalSection !== void 0 && readbackJournalSection.length > 0) {
+    const heading = normalizeJournalHeading(readbackJournalSection);
+    if (!heading.ok || heading.heading !== readbackJournalSection) {
+      throw new RangeError(
+        "activity.timeline.vault.readback.journalSection must be a non-empty trimmed single-line heading"
+      );
+    }
+  }
   const readback = {
     journalSection: readbackJournalSection ?? ""
   };
@@ -1248,6 +1492,11 @@ export {
   expandVaultTemplateTokens,
   validateVaultNoteTemplate,
   resolveVaultNotePath,
+  applyManagedRegion,
+  fileLines,
+  parseAtxHeading,
+  headingSurvivesRoundTrip,
+  publishVaultRegion,
   validateRegionName,
   ANALYSIS_FAILURE_KINDS,
   isAnalysisFailureKind,
@@ -1277,4 +1526,4 @@ export {
   parseActivityConfig,
   parseTimelineVaultConfig
 };
-//# sourceMappingURL=chunk-5HYUUFMQ.js.map
+//# sourceMappingURL=chunk-XCPNH2MG.js.map