@taurgis/bonsai 1.0.0 → 1.0.1

package/dist/commands/config/set.d.ts

@@ -20,12 +20,3 @@ export default class ConfigSet extends ConfigCommand<typeof ConfigSet> {
     init(): Promise<void>;
     execute(): Promise<unknown>;
 }
-/**
- * Accept the `key=value` convenience form alongside the canonical `key value`.
- * Splits only when no separate value positional was supplied, and on the FIRST `=`
- * so a value may itself contain `=`.
- */
-export declare function splitInlineKeyValue(rawKey: string | undefined, rawValue: string | undefined): {
-    keyArg: string | undefined;
-    valueArg: string | undefined;
-};

package/dist/commands/config/set.js

@@ -83,7 +83,7 @@ export default class ConfigSet extends ConfigCommand {
  * Splits only when no separate value positional was supplied, and on the FIRST `=`
  * so a value may itself contain `=`.
  */
-export function splitInlineKeyValue(rawKey, rawValue) {
+function splitInlineKeyValue(rawKey, rawValue) {
     if (rawValue === undefined && rawKey !== undefined) {
         const eq = rawKey.indexOf('=');
         if (eq !== -1) {

package/dist/lib/atomic-write.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Writes `content` to `dest` atomically: write a sibling temp file, then rename it into place.
+ * `rename(2)` is atomic on the same filesystem, so a reader never sees a half-written file. The temp
+ * lives in `dest`'s directory so the rename never crosses a mount boundary (which would fail EXDEV),
+ * and the unique suffix keeps two rapid writers to the same `dest` from clobbering each other's temp.
+ * The temp file is cleaned up if the rename throws.
+ */
+export declare function atomicWriteFile(dest: string, content: string): void;

package/dist/lib/atomic-write.js

@@ -0,0 +1,25 @@
+import { writeFileSync, renameSync, unlinkSync, existsSync } from 'node:fs';
+/**
+ * Writes `content` to `dest` atomically: write a sibling temp file, then rename it into place.
+ * `rename(2)` is atomic on the same filesystem, so a reader never sees a half-written file. The temp
+ * lives in `dest`'s directory so the rename never crosses a mount boundary (which would fail EXDEV),
+ * and the unique suffix keeps two rapid writers to the same `dest` from clobbering each other's temp.
+ * The temp file is cleaned up if the rename throws.
+ */
+export function atomicWriteFile(dest, content) {
+    const tmp = `${dest}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 7)}.tmp`;
+    try {
+        writeFileSync(tmp, content, 'utf-8');
+        renameSync(tmp, dest);
+    }
+    catch (err) {
+        // A failed temp write or rename must not leave the half-written temp behind.
+        if (existsSync(tmp)) {
+            try {
+                unlinkSync(tmp);
+            }
+            catch { }
+        }
+        throw err;
+    }
+}

package/dist/lib/config/io.js

@@ -1,5 +1,6 @@
-import { readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync, existsSync, } from 'node:fs';
+import { readFileSync, mkdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { atomicWriteFile } from '../atomic-write.js';
 import { KEY_META, ALL_KEYS } from './schema.js';
 /** Global, user-level config lives in the OCLIF config dir; project config sits at the repo root. */
 export const USER_CONFIG_FILENAME = 'config.json';
@@ -43,21 +44,7 @@ export function readProjectConfig(cwd) {
     return readConfigFile(join(cwd, PROJECT_CONFIG_FILENAME));
 }
 function writeAtomically(filePath, data) {
-    // Unique per call so two rapid writes to the same file (e.g. a programmatic invoker) can't
-    // share — and clobber — the same temp before its rename. Mirrors writeArtifact in storage.ts.
-    const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 7)}.tmp`;
-    const content = JSON.stringify(data, null, 2) + '\n';
-    try {
-        writeFileSync(tempPath, content, 'utf-8');
-        renameSync(tempPath, filePath);
-    }
-    catch (error) {
-        try {
-            unlinkSync(tempPath);
-        }
-        catch { }
-        throw error;
-    }
+    atomicWriteFile(filePath, JSON.stringify(data, null, 2) + '\n');
 }
 function omitUndefined(obj) {
     return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));

package/dist/lib/research/docs/validate.d.ts

@@ -11,5 +11,3 @@ export declare function isSameDocsOrigin(candidateUrl: string, baseUrl: string):
  * not a soft error page. HTML returned for a `.md`/`.txt` probe is the most common false positive.
  */
 export declare function validateTextArtifact(body: string): ArtifactValidation;
-/** Validates a JSON search-index body parses and is a non-empty object/array. */
-export declare function validateJsonArtifact(body: string): ArtifactValidation;

package/dist/lib/research/docs/validate.js

@@ -39,25 +39,3 @@ export function validateTextArtifact(body) {
         return { ok: false, reason: 'body looks like an error page' };
     return { ok: true };
 }
-/** Validates a JSON search-index body parses and is a non-empty object/array. */
-export function validateJsonArtifact(body) {
-    const trimmed = body.trim();
-    if (trimmed.length < MIN_BODY_CHARS)
-        return { ok: false, reason: 'empty body' };
-    if (looksLikeHtml(trimmed))
-        return { ok: false, reason: 'body is HTML, not JSON' };
-    let parsed;
-    try {
-        parsed = JSON.parse(trimmed);
-    }
-    catch (err) {
-        return { ok: false, reason: `invalid JSON: ${err.message}` };
-    }
-    if (parsed === null || typeof parsed !== 'object') {
-        return { ok: false, reason: 'JSON is not an object or array' };
-    }
-    if (Array.isArray(parsed) ? parsed.length === 0 : Object.keys(parsed).length === 0) {
-        return { ok: false, reason: 'JSON is empty' };
-    }
-    return { ok: true };
-}

package/dist/lib/research/freshness.js

@@ -1,3 +1,5 @@
+const HOUR_MS = 3600 * 1000;
+const DAY_MS = 24 * HOUR_MS;
 /**
  * Parses simple TTL duration strings (e.g. '24h', '7d', '30d') to milliseconds.
  */
@@ -8,19 +10,17 @@ export function parseTtlToMs(ttl) {
     }
     const val = parseInt(match[1] || '', 10);
     const unit = match[2] || '';
-    const hour = 3600 * 1000;
-    const day = 24 * hour;
     switch (unit) {
         case 'h':
-            return val * hour;
+            return val * HOUR_MS;
         case 'd':
-            return val * day;
+            return val * DAY_MS;
         case 'w':
-            return val * 7 * day;
+            return val * 7 * DAY_MS;
         case 'm':
-            return val * 30 * day;
+            return val * 30 * DAY_MS;
         case 'y':
-            return val * 365 * day;
+            return val * 365 * DAY_MS;
         default:
             return 0;
     }
@@ -29,22 +29,21 @@ export function parseTtlToMs(ttl) {
  * Derives the active freshness policy based on the tier and optional TTL override.
  */
 export function getPolicy(tier, ttlOverride) {
-    const day = 24 * 3600 * 1000;
-    let freshWindowMs = 30 * day;
-    let graceWindowMs = 14 * day;
+    let freshWindowMs = 30 * DAY_MS;
+    let graceWindowMs = 14 * DAY_MS;
     if (tier === 'stable') {
-        freshWindowMs = 180 * day;
-        graceWindowMs = 60 * day;
+        freshWindowMs = 180 * DAY_MS;
+        graceWindowMs = 60 * DAY_MS;
     }
     else if (tier === 'volatile') {
-        freshWindowMs = 7 * day;
-        graceWindowMs = 5 * day;
+        freshWindowMs = 7 * DAY_MS;
+        graceWindowMs = 5 * DAY_MS;
     }
     const activeTtl = ttlOverride;
     if (activeTtl) {
         freshWindowMs = parseTtlToMs(activeTtl);
-        const defaultFresh = tier === 'stable' ? 180 * day : tier === 'volatile' ? 7 * day : 30 * day;
-        const defaultGrace = tier === 'stable' ? 60 * day : tier === 'volatile' ? 5 * day : 14 * day;
+        const defaultFresh = tier === 'stable' ? 180 * DAY_MS : tier === 'volatile' ? 7 * DAY_MS : 30 * DAY_MS;
+        const defaultGrace = tier === 'stable' ? 60 * DAY_MS : tier === 'volatile' ? 5 * DAY_MS : 14 * DAY_MS;
         graceWindowMs = Math.floor(freshWindowMs * (defaultGrace / defaultFresh));
     }
     return { freshWindowMs, graceWindowMs };

package/dist/lib/research/storage.js

@@ -1,5 +1,6 @@
 import { join } from 'node:path';
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, renameSync, } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, renameSync } from 'node:fs';
+import { atomicWriteFile } from '../atomic-write.js';
 import { parseArtifact, serializeArtifact } from './artifact.js';
 function isResearchFile(file) {
     return (file.endsWith('.md') &&
@@ -114,30 +115,26 @@ export function writeArtifact(dataDir, key, artifact) {
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
-    const tmpPath = `${path}.${Date.now()}.${Math.random().toString(36).substring(2, 7)}.tmp`;
-    const content = serializeArtifact(artifact);
-    writeFileSync(tmpPath, content, 'utf-8');
-    try {
-        if (existsSync(path)) {
-            try {
-                const existingContent = readFileSync(path, 'utf-8');
-                const archivePath = join(dir, `${key}.superseded.${Date.now()}.md`);
-                writeFileSync(archivePath, existingContent, 'utf-8');
-            }
-            catch (err) {
-                console.warn(`Warning: failed to archive superseded artifact: ${err.message}`);
-            }
+    // Capture the current artifact before overwriting it, then commit the new content atomically.
+    // Archiving is best-effort and happens only after the write succeeds: a read/archive failure
+    // never aborts the write, and a failed write never leaves a stray `.superseded` copy.
+    let existingContent = null;
+    if (existsSync(path)) {
+        try {
+            existingContent = readFileSync(path, 'utf-8');
+        }
+        catch (err) {
+            console.warn(`Warning: failed to read artifact for archiving: ${err.message}`);
         }
-        renameSync(tmpPath, path);
     }
-    catch (err) {
-        if (existsSync(tmpPath)) {
-            try {
-                unlinkSync(tmpPath);
-            }
-            catch { }
+    atomicWriteFile(path, serializeArtifact(artifact));
+    if (existingContent !== null) {
+        try {
+            writeFileSync(join(dir, `${key}.superseded.${Date.now()}.md`), existingContent, 'utf-8');
+        }
+        catch (err) {
+            console.warn(`Warning: failed to archive superseded artifact: ${err.message}`);
         }
-        throw err;
     }
 }
 /**

package/oclif.manifest.json

@@ -841,5 +841,5 @@
       "stdoutIsPrimaryData": true
     }
   },
-  "version": "1.0.0"
+  "version": "1.0.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taurgis/bonsai",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Bonsai is a standalone local research cache CLI for AI agents",
   "type": "module",
   "main": "./dist/index.js",