@indigoai-us/hq-cli 5.316.0 → 5.317.0

package/dist/commands/core-session-journal-native.js

@@ -0,0 +1,327 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveSessionHelperRuntime } from "./core-session-helper-runtime.js";
+const USAGE = `session-journal.sh: usage:
+  session-journal.sh write "<title>" [--files f1,f2,...] [--body-file PATH] [--session KEY]
+  session-journal.sh list [--date YYYY-MM-DD]
+  session-journal.sh read <NNN> [--date YYYY-MM-DD]
+  session-journal.sh index-path [--date YYYY-MM-DD]
+  session-journal.sh dir-path [--date YYYY-MM-DD]
+  session-journal.sh tool-counter (increment|read|reset) [--session KEY]
+`;
+const counterKey = (value) => {
+    let key = [...Buffer.from(value, "utf8")]
+        .map((byte) => (byte >= 0x41 && byte <= 0x5a)
+        || (byte >= 0x61 && byte <= 0x7a)
+        || (byte >= 0x30 && byte <= 0x39)
+        || byte === 0x2e || byte === 0x5f || byte === 0x2d
+        ? String.fromCharCode(byte) : "_")
+        .join("")
+        .replace(/^_/, "")
+        .replace(/_$/, "");
+    if (!key)
+        key = "unscoped";
+    return key.length > 96 ? key.slice(0, 96) : key;
+};
+const slugify = (value) => value.toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 40);
+const warning = (message) => { process.stderr.write(`session-journal: ${message}\n`); };
+const journalDir = (root, date) => path.join(root, "workspace/threads/journal", date);
+const hasFile = (file) => {
+    try {
+        return fs.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const readCounter = (file) => {
+    let raw = "";
+    try {
+        if (hasFile(file))
+            raw = fs.readFileSync(file, "utf8").replace(/[^0-9]/g, "");
+    }
+    catch { /* grep/tr failure is empty */ }
+    return Number.parseInt(raw || "0", 10) || 0;
+};
+const sleepSync = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+function acquireJournalWriteLock(dir) {
+    const lock = path.join(dir, ".session-journal-write.lock");
+    const ownerFile = path.join(lock, "pid");
+    const deadline = Date.now() + 5_000;
+    while (Date.now() < deadline) {
+        try {
+            fs.mkdirSync(lock);
+            try {
+                fs.writeFileSync(ownerFile, `${process.pid}\n`, { flag: "wx" });
+            }
+            catch (error) {
+                fs.rmSync(lock, { recursive: true, force: true });
+                return undefined;
+            }
+            return lock;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                return undefined;
+            let owner = 0;
+            try {
+                owner = Number.parseInt(fs.readFileSync(ownerFile, "utf8"), 10) || 0;
+            }
+            catch { /* new owner has not written its pid yet */ }
+            if (owner > 0 && !processIsAlive(owner)) {
+                let confirmedOwner = 0;
+                try {
+                    confirmedOwner = Number.parseInt(fs.readFileSync(ownerFile, "utf8"), 10) || 0;
+                }
+                catch { /* lock disappeared */ }
+                if (confirmedOwner === owner) {
+                    const stale = `${lock}.stale-${process.pid}-${Math.random().toString(16).slice(2)}`;
+                    try {
+                        fs.renameSync(lock, stale);
+                        fs.rmSync(stale, { recursive: true, force: true });
+                    }
+                    catch { /* another waiter reclaimed it */ }
+                    continue;
+                }
+            }
+            sleepSync(20);
+        }
+    }
+    return undefined;
+}
+function releaseJournalWriteLock(lock) {
+    try {
+        const owner = Number.parseInt(fs.readFileSync(path.join(lock, "pid"), "utf8"), 10);
+        if (owner === process.pid)
+            fs.rmSync(lock, { recursive: true, force: true });
+    }
+    catch { /* shell lock cleanup is best-effort */ }
+}
+function withCounterLock(lock, action) {
+    let i = 0;
+    let acquired = false;
+    while (!acquired) {
+        try {
+            fs.mkdirSync(lock);
+            acquired = true;
+        }
+        catch {
+            i++;
+            if (i >= 50)
+                break;
+            sleepSync(20);
+        }
+    }
+    action();
+    try {
+        fs.rmdirSync(lock);
+    }
+    catch { /* shell rmdir is best-effort */ }
+}
+function nextSequence(dir) {
+    let names = [];
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch { /* ls failure becomes no matches */ }
+    const sequences = names.filter((name) => /^\d{3}-/.test(name))
+        .map((name) => Number(name.match(/^(\d+)-/)?.[1] ?? 0))
+        .filter((value) => Number.isFinite(value));
+    const high = sequences.length ? Math.max(...sequences) + 1 : 1;
+    return String(high).padStart(3, "0");
+}
+function options(args, valueFlags) {
+    const values = new Map();
+    for (let i = 0; i < args.length; i++) {
+        if (valueFlags.includes(args[i]))
+            values.set(args[i], args[++i] ?? "");
+    }
+    return values;
+}
+function runToolCounter(root, action, sessionArg, env, now) {
+    const rawKey = sessionArg || env.HQ_JOURNAL_SESSION || env.HQ_HOOK_SESSION_ID || "";
+    const key = counterKey(rawKey);
+    const dir = journalDir(root, now().toISOString().slice(0, 10));
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { /* legacy mkdir failure is ignored */ }
+    const counter = path.join(dir, `.tool-count-${key}`);
+    const lock = `${counter}.lock`;
+    if (action === "increment") {
+        withCounterLock(lock, () => {
+            try {
+                fs.writeFileSync(counter, `${readCounter(counter) + 1}\n`);
+            }
+            catch { /* fail soft */ }
+        });
+    }
+    else if (action === "read") {
+        process.stdout.write(`${readCounter(counter)}\n`);
+    }
+    else if (action === "reset") {
+        withCounterLock(lock, () => {
+            try {
+                fs.writeFileSync(counter, "0\n");
+            }
+            catch { /* fail soft */ }
+        });
+    }
+    else {
+        warning("tool-counter: subcommand required (increment|read|reset)");
+    }
+}
+/** Native implementation of the fail-soft session journal helper. */
+export function runSessionJournalFast(args, _stdin, cwd, hqRoot, dependencies = {}) {
+    const runtime = resolveSessionHelperRuntime(dependencies);
+    const today = () => runtime.now().toISOString().slice(0, 10);
+    const nowIso = () => runtime.now().toISOString().replace(/\.\d{3}Z$/, "Z");
+    const nowHhmm = () => runtime.now().toISOString().slice(11, 16) + "Z";
+    const root = hqRoot ?? cwd;
+    const [command = "", ...rest] = args;
+    if (command === "write") {
+        const title = rest[0] ?? "";
+        const flags = options(rest.slice(1), ["--files", "--body-file", "--session"]);
+        const files = flags.get("--files") ?? "";
+        const bodyFile = flags.get("--body-file") ?? "";
+        const session = flags.get("--session") ?? "";
+        if (!title) {
+            warning("write: title required");
+            return 0;
+        }
+        const date = today();
+        const dir = journalDir(root, date);
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        catch {
+            warning(`write: mkdir failed: ${dir}`);
+            return 0;
+        }
+        const slug = slugify(title) || "entry";
+        const body = bodyFile && hasFile(bodyFile)
+            ? fs.readFileSync(bodyFile, "utf8")
+            : "## Goal\n\n## Findings\n\n## Decisions\n\n## Next\n";
+        const writeLock = acquireJournalWriteLock(dir);
+        if (!writeLock) {
+            warning("write: failed to acquire journal lock");
+            return 0;
+        }
+        let seq = "";
+        let output = "";
+        let created = false;
+        try {
+            for (let attempt = 0; attempt < 10_000; attempt += 1) {
+                seq = nextSequence(dir);
+                output = path.join(dir, `${seq}-${slug}.md`);
+                const lines = ["---\n", `ts: ${nowIso()}\n`, `title: ${title}\n`, `slug: ${slug}\n`];
+                if (files) {
+                    lines.push("files:\n");
+                    for (const file of files.split(","))
+                        if (file)
+                            lines.push(`  - ${file}\n`);
+                }
+                lines.push("status: closed\n", "---\n\n", `# ${seq} — ${title}\n\n`);
+                try {
+                    fs.writeFileSync(output, lines.join("") + body, { flag: "wx" });
+                    created = true;
+                    break;
+                }
+                catch (error) {
+                    if (error.code === "EEXIST")
+                        continue;
+                    warning(`write: failed to write ${output}`);
+                    return 0;
+                }
+            }
+            if (!created) {
+                warning(`write: failed to write ${output}`);
+                return 0;
+            }
+            const index = path.join(dir, "INDEX.md");
+            if (!hasFile(index)) {
+                try {
+                    fs.writeFileSync(index, `# Session journal — ${date}\n\n`);
+                }
+                catch { /* shell ignores initial failure */ }
+            }
+            try {
+                fs.appendFileSync(index, `- \`${seq}\` ${nowHhmm()} — ${title}\n`);
+            }
+            catch {
+                warning("write: INDEX update failed");
+            }
+        }
+        finally {
+            releaseJournalWriteLock(writeLock);
+        }
+        runToolCounter(root, "reset", counterKey(session || runtime.env.HQ_JOURNAL_SESSION || runtime.env.HQ_HOOK_SESSION_ID || ""), runtime.env, runtime.now);
+        process.stdout.write(`${output}\n`);
+        return 0;
+    }
+    if (command === "list" || command === "read" || command === "index-path" || command === "dir-path") {
+        const sequence = command === "read" ? rest[0] ?? "" : "";
+        const afterSequence = command === "read" ? rest.slice(1) : rest;
+        const date = options(afterSequence, ["--date"]).get("--date") || today();
+        const dir = journalDir(root, date);
+        if (command === "dir-path") {
+            process.stdout.write(dir);
+            return 0;
+        }
+        if (command === "index-path") {
+            process.stdout.write(`${dir}/INDEX.md\n`);
+            return 0;
+        }
+        if (command === "list") {
+            const index = path.join(dir, "INDEX.md");
+            if (hasFile(index))
+                process.stdout.write(fs.readFileSync(index));
+            else
+                process.stdout.write(`(no journal for ${date})\n`);
+            return 0;
+        }
+        if (!sequence) {
+            warning("read: NNN required");
+            return 0;
+        }
+        if (!/^[0-9]{1,18}$/.test(sequence)) {
+            warning("read: NNN required");
+            return 0;
+        }
+        const normalized = BigInt(sequence).toString().padStart(3, "0");
+        const match = (() => {
+            try {
+                return fs.readdirSync(dir).find((name) => name.startsWith(`${normalized}-`));
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        if (match)
+            process.stdout.write(fs.readFileSync(path.join(dir, match)));
+        else
+            warning(`read: no entry ${normalized} for ${date}`);
+        return 0;
+    }
+    if (command === "tool-counter") {
+        const action = rest[0] ?? "";
+        const session = options(rest.slice(1), ["--session"]).get("--session") ?? "";
+        runToolCounter(root, action, session, runtime.env, runtime.now);
+        return 0;
+    }
+    process.stderr.write(USAGE);
+    return 1;
+}
+//# sourceMappingURL=core-session-journal-native.js.map

package/dist/commands/core-session-project-native.d.ts

@@ -0,0 +1,3 @@
+import { type SessionHelperRuntimeOverrides } from "./core-session-helper-runtime.js";
+export declare function runSessionProjectFast(argv: readonly string[], stdin: string, cwd: string, root: string | undefined, dependencies?: SessionHelperRuntimeOverrides): number;
+//# sourceMappingURL=core-session-project-native.d.ts.map