sidekick-shared 0.22.0 → 0.23.1

package/dist/writers/atomic.js

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atomicWriteJson = atomicWriteJson;
+exports.atomicWriteJsonSync = atomicWriteJsonSync;
+exports.updateJsonStoreAtomic = updateJsonStoreAtomic;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const LOCK_STALE_MS = 10_000;
+async function syncDirectory(directory) {
+    let handle;
+    try {
+        handle = await fs.promises.open(directory, 'r');
+        await handle.sync();
+    }
+    catch (error) {
+        const code = error.code;
+        if (!['EISDIR', 'EINVAL', 'ENOSYS', 'EPERM', 'EACCES'].includes(code ?? ''))
+            throw error;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function syncDirectorySync(directory) {
+    let descriptor;
+    try {
+        descriptor = fs.openSync(directory, 'r');
+        fs.fsyncSync(descriptor);
+    }
+    catch (error) {
+        const code = error.code;
+        if (!['EISDIR', 'EINVAL', 'ENOSYS', 'EPERM', 'EACCES'].includes(code ?? ''))
+            throw error;
+    }
+    finally {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+    }
+}
+async function atomicWriteJson(filePath, value) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const tempPath = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`;
+    let handle;
+    try {
+        handle = await fs.promises.open(tempPath, 'wx', 0o600);
+        await handle.writeFile(JSON.stringify(value, null, 2), 'utf8');
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await fs.promises.rename(tempPath, filePath);
+        await syncDirectory(path.dirname(filePath));
+    }
+    catch (error) {
+        await handle?.close().catch(() => undefined);
+        await fs.promises.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function atomicWriteJsonSync(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const tempPath = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`;
+    let descriptor;
+    try {
+        descriptor = fs.openSync(tempPath, 'wx', 0o600);
+        fs.writeFileSync(descriptor, JSON.stringify(value, null, 2), { encoding: 'utf8' });
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = undefined;
+        fs.renameSync(tempPath, filePath);
+        syncDirectorySync(path.dirname(filePath));
+    }
+    catch (error) {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+        fs.rmSync(tempPath, { force: true });
+        throw error;
+    }
+}
+/** Serializes read-modify-write cycles across Sidekick processes. */
+async function updateJsonStoreAtomic(filePath, createEmpty, update) {
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const lockPath = `${filePath}.lock`;
+    const lock = await acquireLock(lockPath);
+    try {
+        let latest = createEmpty();
+        let raw;
+        try {
+            raw = await fs.promises.readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (raw !== undefined) {
+            try {
+                latest = JSON.parse(raw);
+            }
+            catch {
+                const corruptPath = `${filePath}.corrupt-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+                await fs.promises.rename(filePath, corruptPath);
+            }
+        }
+        const next = await update(latest);
+        await atomicWriteJson(filePath, next);
+        return next;
+    }
+    finally {
+        await releaseLock(lockPath, lock);
+    }
+}
+async function acquireLock(lockPath) {
+    const deadline = Date.now() + 3000;
+    while (true) {
+        try {
+            const handle = await fs.promises.open(lockPath, 'wx', 0o600);
+            const token = `${process.pid}:${crypto.randomBytes(16).toString('hex')}`;
+            await handle.writeFile(token, 'utf8');
+            await handle.sync();
+            const heartbeat = setInterval(() => {
+                fs.promises.utimes(lockPath, new Date(), new Date()).catch(() => undefined);
+            }, Math.floor(LOCK_STALE_MS / 3));
+            heartbeat.unref();
+            return { handle, token, heartbeat };
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            try {
+                const stat = await fs.promises.stat(lockPath);
+                if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                    const owner = await fs.promises.readFile(lockPath, 'utf8').catch(() => '');
+                    const ownerPid = Number.parseInt(owner.split(':', 1)[0], 10);
+                    let ownerAlive = Number.isInteger(ownerPid) && ownerPid > 0;
+                    if (ownerAlive) {
+                        try {
+                            process.kill(ownerPid, 0);
+                        }
+                        catch (ownerError) {
+                            ownerAlive = ownerError.code === 'EPERM';
+                        }
+                    }
+                    if (!ownerAlive)
+                        await fs.promises.rm(lockPath, { force: true });
+                }
+            }
+            catch {
+                // The other writer released between checks.
+            }
+            if (Date.now() >= deadline)
+                throw new Error(`Timed out waiting for store lock: ${lockPath}`);
+            await new Promise((resolve) => setTimeout(resolve, 15));
+        }
+    }
+}
+async function releaseLock(lockPath, lock) {
+    clearInterval(lock.heartbeat);
+    await lock.handle.close().catch(() => undefined);
+    try {
+        const currentToken = await fs.promises.readFile(lockPath, 'utf8');
+        if (currentToken === lock.token)
+            await fs.promises.rm(lockPath, { force: true });
+    }
+    catch {
+        // The lock was already released or replaced; never delete another owner's lock.
+    }
+}

package/dist/writers/decisions.d.ts

@@ -0,0 +1,12 @@
+import { type DecisionEntry, type DecisionSource } from '../types/decisionLog';
+export declare function decisionFingerprint(decision: Pick<DecisionEntry, 'source' | 'description'>): string;
+export declare function addDecision(cwd: string, description: string, options?: {
+    rationale?: string;
+    chosenOption?: string;
+    alternatives?: string[];
+    tags?: string[];
+    source?: DecisionSource;
+}): Promise<{
+    decision: DecisionEntry;
+    added: boolean;
+}>;

package/dist/writers/decisions.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decisionFingerprint = decisionFingerprint;
+exports.addDecision = addDecision;
+const crypto = __importStar(require("crypto"));
+const paths_1 = require("../paths");
+const projectMigration_1 = require("../projectMigration");
+const decisionLog_1 = require("../types/decisionLog");
+const atomic_1 = require("./atomic");
+function emptyDecisionStore() {
+    return {
+        schemaVersion: decisionLog_1.DECISION_LOG_SCHEMA_VERSION,
+        decisions: {},
+        lastSessionId: 'cli',
+        lastSaved: new Date().toISOString(),
+    };
+}
+function decisionFingerprint(decision) {
+    return `${decision.source}::${decision.description.toLowerCase().trim()}`;
+}
+async function addDecision(cwd, description, options = {}) {
+    const project = (0, paths_1.resolveProjectIdentity)(cwd);
+    (0, projectMigration_1.migrateLegacyProjectStores)(project);
+    const filePath = (0, paths_1.getProjectDataPath)(project.canonicalSlug, 'decisions');
+    const decision = {
+        id: crypto.randomUUID(),
+        description: description.trim(),
+        rationale: options.rationale?.trim() || 'Captured from the Sidekick CLI.',
+        chosenOption: options.chosenOption?.trim() || description.trim(),
+        alternatives: options.alternatives,
+        source: options.source ?? 'text_pattern',
+        sessionId: 'cli',
+        timestamp: new Date().toISOString(),
+        tags: options.tags,
+    };
+    let added = false;
+    let persisted = decision;
+    await (0, atomic_1.updateJsonStoreAtomic)(filePath, emptyDecisionStore, (store) => {
+        const fingerprint = decisionFingerprint(decision);
+        const duplicate = Object.values(store.decisions).find((entry) => decisionFingerprint(entry) === fingerprint);
+        if (duplicate) {
+            persisted = duplicate;
+            return store;
+        }
+        added = true;
+        return {
+            ...store,
+            schemaVersion: decisionLog_1.DECISION_LOG_SCHEMA_VERSION,
+            decisions: { ...store.decisions, [decision.id]: decision },
+            lastSessionId: 'cli',
+            lastSaved: decision.timestamp,
+        };
+    });
+    return { decision: persisted, added };
+}

package/dist/writers/notes.d.ts

@@ -0,0 +1,8 @@
+import { type KnowledgeNote, type KnowledgeNoteImportance, type KnowledgeNoteType } from '../types/knowledgeNote';
+export declare function addNote(cwd: string, content: string, options?: {
+    filePath?: string;
+    title?: string;
+    noteType?: KnowledgeNoteType;
+    importance?: KnowledgeNoteImportance;
+    tags?: string[];
+}): Promise<KnowledgeNote>;

package/dist/writers/notes.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNote = addNote;
+const crypto = __importStar(require("crypto"));
+const paths_1 = require("../paths");
+const projectMigration_1 = require("../projectMigration");
+const knowledgeNote_1 = require("../types/knowledgeNote");
+const atomic_1 = require("./atomic");
+function emptyNoteStore() {
+    return {
+        schemaVersion: knowledgeNote_1.KNOWLEDGE_NOTE_SCHEMA_VERSION,
+        notesByFile: {},
+        lastSaved: new Date().toISOString(),
+        totalNotes: 0,
+    };
+}
+async function addNote(cwd, content, options = {}) {
+    const project = (0, paths_1.resolveProjectIdentity)(cwd);
+    (0, projectMigration_1.migrateLegacyProjectStores)(project);
+    const filePath = (0, paths_1.getProjectDataPath)(project.canonicalSlug, 'knowledge-notes');
+    const now = new Date().toISOString();
+    const notePath = options.filePath?.trim() || '.';
+    const note = {
+        id: crypto.randomUUID(),
+        noteType: options.noteType ?? 'tip',
+        content: content.trim(),
+        title: options.title,
+        filePath: notePath,
+        source: 'manual',
+        status: 'active',
+        importance: options.importance ?? 'medium',
+        createdAt: now,
+        updatedAt: now,
+        lastReviewedAt: now,
+        tags: options.tags,
+    };
+    await (0, atomic_1.updateJsonStoreAtomic)(filePath, emptyNoteStore, (store) => {
+        const existing = store.notesByFile[notePath] ?? [];
+        const notesByFile = { ...store.notesByFile, [notePath]: [...existing, note] };
+        return {
+            ...store,
+            schemaVersion: knowledgeNote_1.KNOWLEDGE_NOTE_SCHEMA_VERSION,
+            notesByFile,
+            totalNotes: Object.values(notesByFile).reduce((sum, notes) => sum + notes.length, 0),
+            lastSaved: now,
+        };
+    });
+    return note;
+}

package/dist/writers/tasks.d.ts

@@ -0,0 +1,6 @@
+import { type PersistedTask } from '../types/taskPersistence';
+export declare function addTask(cwd: string, subject: string, options?: {
+    description?: string;
+    tags?: string[];
+}): Promise<PersistedTask>;
+export declare function completeTask(cwd: string, taskIdOrPrefix: string): Promise<PersistedTask>;

package/dist/writers/tasks.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTask = addTask;
+exports.completeTask = completeTask;
+const crypto = __importStar(require("crypto"));
+const paths_1 = require("../paths");
+const projectMigration_1 = require("../projectMigration");
+const taskPersistence_1 = require("../types/taskPersistence");
+const atomic_1 = require("./atomic");
+function emptyTaskStore() {
+    return {
+        schemaVersion: taskPersistence_1.TASK_PERSISTENCE_SCHEMA_VERSION,
+        tasks: {},
+        lastSessionId: 'cli',
+        sessionCount: 0,
+        lastSaved: new Date().toISOString(),
+    };
+}
+async function addTask(cwd, subject, options = {}) {
+    const project = (0, paths_1.resolveProjectIdentity)(cwd);
+    (0, projectMigration_1.migrateLegacyProjectStores)(project);
+    const filePath = (0, paths_1.getProjectDataPath)(project.canonicalSlug, 'tasks');
+    const now = new Date().toISOString();
+    const task = {
+        taskId: crypto.randomUUID(),
+        subject: subject.trim(),
+        description: options.description,
+        status: 'pending',
+        createdAt: now,
+        updatedAt: now,
+        toolCallCount: 0,
+        blockedBy: [],
+        blocks: [],
+        sessionOrigin: 'cli',
+        carriedOver: false,
+        sessionAge: 0,
+        tags: options.tags,
+    };
+    await (0, atomic_1.updateJsonStoreAtomic)(filePath, emptyTaskStore, (store) => ({
+        ...store,
+        schemaVersion: taskPersistence_1.TASK_PERSISTENCE_SCHEMA_VERSION,
+        tasks: { ...store.tasks, [task.taskId]: task },
+        lastSessionId: store.lastSessionId || 'cli',
+        lastSaved: now,
+    }));
+    return task;
+}
+async function completeTask(cwd, taskIdOrPrefix) {
+    const project = (0, paths_1.resolveProjectIdentity)(cwd);
+    (0, projectMigration_1.migrateLegacyProjectStores)(project);
+    const filePath = (0, paths_1.getProjectDataPath)(project.canonicalSlug, 'tasks');
+    let completed;
+    await (0, atomic_1.updateJsonStoreAtomic)(filePath, emptyTaskStore, (store) => {
+        const matches = Object.values(store.tasks).filter((task) => task.taskId === taskIdOrPrefix || task.taskId.startsWith(taskIdOrPrefix));
+        if (matches.length !== 1) {
+            throw new Error(matches.length === 0 ? `Task not found: ${taskIdOrPrefix}` : 'Task ID is ambiguous');
+        }
+        const now = new Date().toISOString();
+        completed = { ...matches[0], status: 'completed', updatedAt: now };
+        return {
+            ...store,
+            tasks: { ...store.tasks, [completed.taskId]: completed },
+            lastSaved: now,
+        };
+    });
+    return completed;
+}

package/dist/zaiQuotaWatcher.js

@@ -169,6 +169,12 @@ class ZaiQuotaWatcher {
     }
     recomputeAndEmit() {
         const nowMs = this.now();
+        if (this.lastError?.resetsAt) {
+            const resetsAt = Date.parse(this.lastError.resetsAt);
+            if (Number.isFinite(resetsAt) && resetsAt <= nowMs) {
+                this.lastError = null;
+            }
+        }
         const accumulated = (0, zaiQuota_1.accumulateZaiUsage)(this.turns, nowMs);
         const tier = this.resolveTier(this.tier, accumulated);
         const state = accumulated.fiveHourTurns > 0 || accumulated.weeklyTurns > 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,6 +37,10 @@
       "types": "./dist/formatting.d.ts",
       "default": "./dist/formatting.js"
     },
+    "./statusline": {
+      "types": "./dist/statusline/index.d.ts",
+      "default": "./dist/statusline/index.js"
+    },
     "./dist/*": {
       "types": "./dist/*.d.ts",
       "default": "./dist/*.js"