@saasontools/strauss-kb 0.1.8 → 0.1.9

package/dist/index.d.cts

@@ -313,7 +313,7 @@ declare function pack(bundle: KbRecord[], rootId: string, options?: KbPackOption
 
 declare const LOG_FILE = "log.jsonl";
 declare const kbLogEntrySchema: z.ZodObject<{
-    at: z.ZodString;
+    at: z.ZodISODateTime;
     by: z.ZodString;
     operation: z.ZodString;
     conceptId: z.ZodString;
@@ -569,6 +569,47 @@ declare class KbStore {
      * otherwise try to read it mid-write.
      */
     private publish;
+    /**
+     * Declares union merge for the log, so two worktrees writing the same
+     * bundle interleave their `log.jsonl` lines on merge rather than one
+     * side's appends silently losing to git's ordinary line-level merge.
+     *
+     * Called from `record` — every path that appends a log line, not just
+     * `write` — so a bundle only ever mutated through `setStatus`/`verify`/
+     * `supersede` still gets it. There is no cheaper reliable signal for
+     * "first write" than checking the file itself, and after the first call
+     * the check is a no-op `readFile`.
+     *
+     * A missing `.gitattributes` is created outright, with `wx` (exclusive
+     * create) rather than a plain write: if another process's `write()` won a
+     * race and created the file between the `readFile` below and this call,
+     * `wx` fails instead of truncating what that writer just wrote, and the
+     * failure is swallowed by the catch below same as any other best-effort
+     * miss. A file that exists but declares no merge strategy for the log
+     * gets the line appended, never a wholesale rewrite; one that already
+     * declares any merge strategy — this one or a user's own — is left alone
+     * entirely (see `hasMergeDeclaration`).
+     *
+     * `readFile` failing is `existing === null` only for `ENOENT` — genuinely
+     * missing. Any other error (a permission problem, a transient `EMFILE`,
+     * the path being a directory) is *not* "missing" and must not fall into
+     * the create branch, which would truncate whatever is actually there with
+     * just the union-merge line: that is the file-destroying bug this
+     * function exists to avoid, not commit. An unreadable existing file is
+     * therefore left untouched and reported as a failure like any other.
+     *
+     * Two processes racing the append branch — both read a file without the
+     * line, both append it — is possible and left unguarded: `appendFile` is
+     * `O_APPEND`, so the result is two copies of the same line rather than a
+     * torn write, and `hasMergeDeclaration` sees a duplicate declaration as
+     * "already declared" on the next call. A cheap-to-detect, harmless-to-
+     * leave residue, not a reason to add a cross-process lock (see
+     * `ARCHITECTURE.md`'s rejection of one for the same trade on records).
+     *
+     * Best-effort, like the log append it precedes: failing to write this
+     * file must not fail the mutation it guards.
+     */
+    private ensureGitattributes;
     /** Appends one log line. Failing to log must not fail the mutation. */
     private record;
     private parse;

package/dist/index.d.ts

@@ -313,7 +313,7 @@ declare function pack(bundle: KbRecord[], rootId: string, options?: KbPackOption
 
 declare const LOG_FILE = "log.jsonl";
 declare const kbLogEntrySchema: z.ZodObject<{
-    at: z.ZodString;
+    at: z.ZodISODateTime;
     by: z.ZodString;
     operation: z.ZodString;
     conceptId: z.ZodString;
@@ -569,6 +569,47 @@ declare class KbStore {
      * otherwise try to read it mid-write.
      */
     private publish;
+    /**
+     * Declares union merge for the log, so two worktrees writing the same
+     * bundle interleave their `log.jsonl` lines on merge rather than one
+     * side's appends silently losing to git's ordinary line-level merge.
+     *
+     * Called from `record` — every path that appends a log line, not just
+     * `write` — so a bundle only ever mutated through `setStatus`/`verify`/
+     * `supersede` still gets it. There is no cheaper reliable signal for
+     * "first write" than checking the file itself, and after the first call
+     * the check is a no-op `readFile`.
+     *
+     * A missing `.gitattributes` is created outright, with `wx` (exclusive
+     * create) rather than a plain write: if another process's `write()` won a
+     * race and created the file between the `readFile` below and this call,
+     * `wx` fails instead of truncating what that writer just wrote, and the
+     * failure is swallowed by the catch below same as any other best-effort
+     * miss. A file that exists but declares no merge strategy for the log
+     * gets the line appended, never a wholesale rewrite; one that already
+     * declares any merge strategy — this one or a user's own — is left alone
+     * entirely (see `hasMergeDeclaration`).
+     *
+     * `readFile` failing is `existing === null` only for `ENOENT` — genuinely
+     * missing. Any other error (a permission problem, a transient `EMFILE`,
+     * the path being a directory) is *not* "missing" and must not fall into
+     * the create branch, which would truncate whatever is actually there with
+     * just the union-merge line: that is the file-destroying bug this
+     * function exists to avoid, not commit. An unreadable existing file is
+     * therefore left untouched and reported as a failure like any other.
+     *
+     * Two processes racing the append branch — both read a file without the
+     * line, both append it — is possible and left unguarded: `appendFile` is
+     * `O_APPEND`, so the result is two copies of the same line rather than a
+     * torn write, and `hasMergeDeclaration` sees a duplicate declaration as
+     * "already declared" on the next call. A cheap-to-detect, harmless-to-
+     * leave residue, not a reason to add a cross-process lock (see
+     * `ARCHITECTURE.md`'s rejection of one for the same trade on records).
+     *
+     * Best-effort, like the log append it precedes: failing to write this
+     * file must not fail the mutation it guards.
+     */
+    private ensureGitattributes;
     /** Appends one log line. Failing to log must not fail the mutation. */
     private record;
     private parse;

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   runKbCli
-} from "./chunk-MGPYUZOM.js";
+} from "./chunk-KVEEISYQ.js";
 import {
   createKbMcpServer,
   runKbMcpServer
-} from "./chunk-YYX6CX6V.js";
+} from "./chunk-MWWDD23L.js";
 import {
   BaseError,
   CONTEXT_BEGIN,
@@ -95,7 +95,7 @@ import {
   trace,
   unpinBase,
   validateBundle
-} from "./chunk-YJK7KGHN.js";
+} from "./chunk-OFDWRMY6.js";
 
 // src/match-diff.ts
 function matchToDiff(files, records, options = {}) {

package/dist/mcp-main.cjs

@@ -1813,7 +1813,15 @@ var import_zod19 = require("zod");
 var import_zod18 = require("zod");
 var LOG_FILE = "log.jsonl";
 var kbLogEntrySchema = import_zod18.z.object({
-  at: import_zod18.z.string().min(1),
+  // Validated, not just `min(1)`: `at` is a sort key (see `parseLog`
+  // below), and a value that isn't actually chronological — a Unix
+  // timestamp, a human-typed date, garbage — would sort wrong without
+  // ever failing to parse. `z.iso.datetime()` accepts exactly what
+  // `record()` writes (`Date#toISOString()`: full precision, `Z` offset)
+  // and rejects everything else, including a non-`Z` offset — so a
+  // malformed `at` is reported the same way a malformed line already is,
+  // rather than silently sorting into the wrong place.
+  at: import_zod18.z.iso.datetime(),
   by: import_zod18.z.string().min(1),
   operation: import_zod18.z.string().min(1),
   conceptId: import_zod18.z.string().min(1),
@@ -1827,6 +1835,7 @@ function renderLogEntry(entry) {
 function parseLog(raw) {
   const entries = [];
   const malformed = [];
+  const seen = /* @__PURE__ */ new Set();
   raw.split("\n").forEach((text, index) => {
     if (!text.trim()) return;
     let value;
@@ -1841,8 +1850,14 @@ function parseLog(raw) {
       malformed.push({ line: index + 1, text });
       return;
     }
+    const key = JSON.stringify(parsed.data);
+    if (seen.has(key)) return;
+    seen.add(key);
     entries.push(parsed.data);
   });
+  entries.sort(
+    (left, right) => left.at < right.at ? -1 : left.at > right.at ? 1 : 0
+  );
   return { entries, malformed };
 }
 
@@ -2509,6 +2524,30 @@ function typeRank(record) {
   return index === -1 ? TYPE_PRIORITY.length : index;
 }
 
+// src/kb-gitattributes.ts
+var GITATTRIBUTES_FILE = ".gitattributes";
+var UNION_MERGE_LINE = `${LOG_FILE} text eol=lf merge=union`;
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) return null;
+  const [pattern, ...attrs] = trimmed.split(/\s+/);
+  return pattern === void 0 ? null : { pattern, attrs };
+}
+function hasMergeDeclaration(contents) {
+  return contents.split("\n").some((line) => {
+    const parsed = parseLine(line);
+    if (!parsed || parsed.pattern !== LOG_FILE) return false;
+    return parsed.attrs.some(
+      (attr) => attr === "merge" || attr === "-merge" || attr.startsWith("merge=")
+    );
+  });
+}
+function appendUnionMergeLine(contents) {
+  const separator = contents.length === 0 || contents.endsWith("\n") ? "" : "\n";
+  return `${separator}${UNION_MERGE_LINE}
+`;
+}
+
 // src/kb-store.ts
 var KB_DIR = (0, import_node_path6.join)(".strauss", "kb");
 var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
@@ -2934,8 +2973,87 @@ ${answer}
       await (0, import_promises4.unlink)(staging).catch(() => void 0);
     }
   }
+  /**
+   * Declares union merge for the log, so two worktrees writing the same
+   * bundle interleave their `log.jsonl` lines on merge rather than one
+   * side's appends silently losing to git's ordinary line-level merge.
+   *
+   * Called from `record` — every path that appends a log line, not just
+   * `write` — so a bundle only ever mutated through `setStatus`/`verify`/
+   * `supersede` still gets it. There is no cheaper reliable signal for
+   * "first write" than checking the file itself, and after the first call
+   * the check is a no-op `readFile`.
+   *
+   * A missing `.gitattributes` is created outright, with `wx` (exclusive
+   * create) rather than a plain write: if another process's `write()` won a
+   * race and created the file between the `readFile` below and this call,
+   * `wx` fails instead of truncating what that writer just wrote, and the
+   * failure is swallowed by the catch below same as any other best-effort
+   * miss. A file that exists but declares no merge strategy for the log
+   * gets the line appended, never a wholesale rewrite; one that already
+   * declares any merge strategy — this one or a user's own — is left alone
+   * entirely (see `hasMergeDeclaration`).
+   *
+   * `readFile` failing is `existing === null` only for `ENOENT` — genuinely
+   * missing. Any other error (a permission problem, a transient `EMFILE`,
+   * the path being a directory) is *not* "missing" and must not fall into
+   * the create branch, which would truncate whatever is actually there with
+   * just the union-merge line: that is the file-destroying bug this
+   * function exists to avoid, not commit. An unreadable existing file is
+   * therefore left untouched and reported as a failure like any other.
+   *
+   * Two processes racing the append branch — both read a file without the
+   * line, both append it — is possible and left unguarded: `appendFile` is
+   * `O_APPEND`, so the result is two copies of the same line rather than a
+   * torn write, and `hasMergeDeclaration` sees a duplicate declaration as
+   * "already declared" on the next call. A cheap-to-detect, harmless-to-
+   * leave residue, not a reason to add a cross-process lock (see
+   * `ARCHITECTURE.md`'s rejection of one for the same trade on records).
+   *
+   * Best-effort, like the log append it precedes: failing to write this
+   * file must not fail the mutation it guards.
+   */
+  async ensureGitattributes(root) {
+    const target = (0, import_node_path6.join)(root, GITATTRIBUTES_FILE);
+    try {
+      let existing;
+      try {
+        existing = await (0, import_promises4.readFile)(target, "utf8");
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        existing = null;
+      }
+      if (existing === null) {
+        await (0, import_promises4.writeFile)(target, appendUnionMergeLine(""), {
+          encoding: "utf8",
+          flag: "wx"
+        });
+        this.logger.info?.({
+          operation: "kb.gitattributes.ensure",
+          bundlePath: root,
+          outcome: "created"
+        });
+        return;
+      }
+      if (!hasMergeDeclaration(existing)) {
+        await (0, import_promises4.appendFile)(target, appendUnionMergeLine(existing), "utf8");
+        this.logger.info?.({
+          operation: "kb.gitattributes.ensure",
+          bundlePath: root,
+          outcome: "appended"
+        });
+      }
+    } catch (error) {
+      this.logger.warn?.({
+        operation: "kb.gitattributes.ensure",
+        outcome: "failed",
+        error: error instanceof Error ? error.message : "unknown"
+      });
+    }
+  }
   /** Appends one log line. Failing to log must not fail the mutation. */
   async record(root, entry) {
+    await this.ensureGitattributes(root);
     const line = renderLogEntry({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
     await (0, import_promises4.appendFile)((0, import_node_path6.join)(root, LOG_FILE), line, "utf8").catch((error) => {
       this.logger.warn?.({
@@ -3009,7 +3127,7 @@ function digest(contents) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.8" : "0.0.0-dev";
+var VERSION = true ? "0.1.9" : "0.0.0-dev";
 
 // src/mcp.ts
 function createKbMcpServer() {