packmind 0.1.0

package/dist/hooks/runtime.js

@@ -0,0 +1,471 @@
+"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.projectRoot = projectRoot;
+exports.stateDir = stateDir;
+exports.brainPath = brainPath;
+exports.requireState = requireState;
+exports.withLock = withLock;
+exports.readText = readText;
+exports.writeText = writeText;
+exports.appendLine = appendLine;
+exports.readJson = readJson;
+exports.writeJson = writeJson;
+exports.lines = lines;
+exports.parseMap = parseMap;
+exports.serializeMap = serializeMap;
+exports.parseNeverDo = parseNeverDo;
+exports.estimateTokens = estimateTokens;
+exports.looksSecret = looksSecret;
+exports.confineToRoot = confineToRoot;
+exports.samePath = samePath;
+exports.inputCost = inputCost;
+exports.outputCost = outputCost;
+exports.evaluateWrite = evaluateWrite;
+exports.describeLite = describeLite;
+exports.hookConfig = hookConfig;
+exports.readStdin = readStdin;
+exports.parseInput = parseInput;
+exports.emitContext = emitContext;
+exports.emitDeny = emitDeny;
+exports.newSession = newSession;
+exports.readSession = readSession;
+exports.writeSession = writeSession;
+exports.enqueueRecall = enqueueRecall;
+/**
+ * Zero-dependency runtime for PackMind's standalone hook scripts.
+ *
+ * Hooks are copied into a user's `.packmind/hooks/` and executed by Claude Code
+ * as plain `node` scripts, so this module imports ONLY Node builtins. The
+ * format functions here mirror src/state/formats.ts, the secret matcher mirrors
+ * src/guard/secrets.ts, and the estimator mirrors src/cost/estimator.ts; a
+ * parity test pins each mirror to its canonical twin.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const crypto = __importStar(require("node:crypto"));
+// --- project + brain paths --------------------------------------------------
+function projectRoot() {
+    return process.env.PACKMIND_ROOT || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+}
+function stateDir() {
+    return path.join(projectRoot(), ".packmind");
+}
+function brainPath(...parts) {
+    return path.join(stateDir(), ...parts);
+}
+/** Exit silently when the project doesn't use PackMind. */
+function requireState() {
+    if (!fs.existsSync(stateDir()))
+        process.exit(0);
+}
+// --- atomic + locked IO -----------------------------------------------------
+const FALLBACK = new Set(["EBUSY", "EACCES", "EPERM", "EXDEV"]);
+function spin(ms) {
+    const until = Date.now() + ms;
+    while (Date.now() < until) {
+        /* brief spin */
+    }
+}
+function withLock(target, body) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const lock = `${target}.lock`;
+    let held = false;
+    for (let i = 0; i < 60; i++) {
+        try {
+            fs.mkdirSync(lock);
+            held = true;
+            break;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            try {
+                if (Date.now() - fs.statSync(lock).mtimeMs > 10_000) {
+                    fs.rmSync(lock, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            catch {
+                /* retry */
+            }
+            spin(20);
+        }
+    }
+    try {
+        return body();
+    }
+    finally {
+        if (held) {
+            try {
+                fs.rmSync(lock, { recursive: true, force: true });
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
+function atomic(target, data) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const tmp = `${target}.${crypto.randomBytes(5).toString("hex")}.tmp`;
+    try {
+        fs.writeFileSync(tmp, data, "utf8");
+        fs.renameSync(tmp, target);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            /* ignore */
+        }
+        if (!FALLBACK.has(err.code ?? ""))
+            throw err;
+        fs.writeFileSync(target, data, "utf8");
+    }
+}
+function readText(target, fallback = "") {
+    try {
+        return fs.readFileSync(target, "utf8");
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeText(target, data) {
+    withLock(target, () => atomic(target, data));
+}
+function appendLine(target, line) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    withLock(target, () => fs.appendFileSync(target, line, "utf8"));
+}
+function readJson(target, fallback) {
+    try {
+        return JSON.parse(fs.readFileSync(target, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJson(target, value) {
+    withLock(target, () => atomic(target, JSON.stringify(value, null, 2) + "\n"));
+}
+const SECTION = /^##\s+(.+?)\s*$/;
+const ENTRY = /^-\s+`([^`]+)`\s+·\s+~(\d+)\s+tok(?:\s+·\s+\$([\d.]+))?(?:\s+—\s+(.*\S))?\s*$/;
+function lines(text) {
+    return text.split(/\r?\n/);
+}
+function parseMap(text) {
+    const out = new Map();
+    let section = "";
+    for (const line of lines(text)) {
+        const s = line.match(SECTION);
+        if (s) {
+            section = s[1].trim();
+            if (!out.has(section))
+                out.set(section, []);
+            continue;
+        }
+        if (!section)
+            continue;
+        const e = line.match(ENTRY);
+        if (e) {
+            out.get(section).push({
+                file: e[1],
+                tokens: parseInt(e[2], 10),
+                cost: e[3] ? Number(e[3]) : undefined,
+                description: e[4] ? e[4].trim() : "",
+            });
+        }
+    }
+    return out;
+}
+function serializeMap(sections, meta) {
+    const out = [
+        "# Project Map",
+        "",
+        `_Maintained by PackMind · ${meta.fileCount} files · updated ${meta.updated}_`,
+        "",
+    ];
+    for (const key of [...sections.keys()].sort()) {
+        const entries = sections.get(key);
+        if (entries.length === 0)
+            continue;
+        out.push(`## ${key}`, "");
+        for (const e of [...entries].sort((a, b) => a.file.localeCompare(b.file))) {
+            const cost = e.cost && e.cost > 0 ? ` · $${e.cost.toFixed(4)}` : "";
+            const desc = e.description ? ` — ${e.description}` : "";
+            out.push(`- \`${e.file}\` · ~${e.tokens} tok${cost}${desc}`);
+        }
+        out.push("");
+    }
+    return out.join("\n");
+}
+function parseNeverDo(knowledge) {
+    const result = [];
+    let active = false;
+    for (const line of lines(knowledge)) {
+        if (/^##\s+/.test(line)) {
+            active = /^##\s+Never\s*Do\b/i.test(line);
+            continue;
+        }
+        if (!active)
+            continue;
+        const m = line.match(/^[-*]\s+(?:\[[\d-]+\]\s*)?(.+?)\s*$/);
+        if (m)
+            result.push(m[1]);
+    }
+    return result;
+}
+// --- tokens (mirror of cost/estimator.ts) -----------------------------------
+const CODE_EXT = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".py", ".rs", ".go", ".java", ".kt", ".c",
+    ".cpp", ".h", ".hpp", ".cs", ".rb", ".php", ".swift", ".scala", ".sh",
+    ".css", ".scss", ".sql", ".json", ".yaml", ".yml", ".toml", ".xml", ".html",
+]);
+function estimateTokens(text, hint) {
+    if (!text)
+        return 0;
+    const ext = hint ? path.extname(hint).toLowerCase() : "";
+    const charsPerToken = CODE_EXT.has(ext) ? 3.5 : 4.0;
+    const byChars = text.length / charsPerToken;
+    const words = text.trim().length ? text.trim().split(/\s+/).length : 0;
+    const byWords = words / 0.75;
+    return Math.max(1, Math.round((byChars + byWords) / 2));
+}
+// --- secrets (mirror of guard/secrets.ts) -----------------------------------
+const SECRET_GLOBS = [
+    ".env", ".env.*", "*.env", "*.pem", "*.key", "*.p8", "*.p12", "*.pfx", "*.ppk",
+    "*.keystore", "*.jks", "*.cer", "*.crt", "*.der", "id_rsa*", "id_dsa*",
+    "id_ecdsa*", "id_ed25519*", "credentials", "credentials.*", ".netrc", ".npmrc",
+    ".pypirc", "*.secret", "*.secrets", "secrets.*", "service-account*.json",
+    "*.kdbx", "*.gpg", "*.asc",
+];
+function toRe(glob) {
+    const body = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${body}$`, "i");
+}
+const SECRET_RES = SECRET_GLOBS.map(toRe);
+function looksSecret(file, extra = []) {
+    const base = path.basename(file);
+    if (SECRET_RES.some((re) => re.test(base)))
+        return true;
+    return extra.map(toRe).some((re) => re.test(base));
+}
+// --- path guard (mirror of guard/path-guard.ts) -----------------------------
+function confineToRoot(root, candidate) {
+    const base = path.resolve(root);
+    const resolved = path.isAbsolute(candidate) ? path.resolve(candidate) : path.resolve(base, candidate);
+    const rel = path.relative(base, resolved);
+    if (rel === "")
+        return resolved;
+    if (rel.startsWith("..") || path.isAbsolute(rel))
+        return null;
+    return resolved;
+}
+function samePath(root, a, b) {
+    const ra = confineToRoot(root, a);
+    const rb = confineToRoot(root, b);
+    return ra !== null && rb !== null && ra === rb;
+}
+// --- pricing (mirror of cost/pricing.ts) ------------------------------------
+const PRICES = {
+    "claude-opus-4-8": { i: 15, o: 75 },
+    "claude-sonnet-4-6": { i: 3, o: 15 },
+    "claude-haiku-4-5": { i: 1, o: 5 },
+    "claude-fable-5": { i: 5, o: 25 },
+};
+function normModel(m) {
+    const s = m.toLowerCase();
+    if (s.includes("opus"))
+        return "claude-opus-4-8";
+    if (s.includes("sonnet"))
+        return "claude-sonnet-4-6";
+    if (s.includes("haiku"))
+        return "claude-haiku-4-5";
+    if (s.includes("fable"))
+        return "claude-fable-5";
+    return "claude-opus-4-8";
+}
+function inputCost(model, tokens) {
+    return (tokens / 1_000_000) * (PRICES[normModel(model)] ?? PRICES["claude-opus-4-8"]).i;
+}
+function outputCost(model, tokens) {
+    return (tokens / 1_000_000) * (PRICES[normModel(model)] ?? PRICES["claude-opus-4-8"]).o;
+}
+function pathGlobRe(glob) {
+    const body = glob
+        .replace(/[.+^${}()|[\]]/g, "\\$&")
+        .replace(/\*\*/g, " ")
+        .replace(/\*/g, "[^/]*")
+        .replace(/ /g, ".*")
+        .replace(/\?/g, ".");
+    return new RegExp(`^${body}$`, "i");
+}
+function evaluateWrite(rules, input) {
+    const findings = [];
+    const isSecret = looksSecret(path.basename(input.relPath), input.extraSecretGlobs);
+    for (const rule of rules ?? []) {
+        const conditions = [];
+        if (rule.secretFile)
+            conditions.push(isSecret);
+        if (rule.pathGlob)
+            conditions.push(pathGlobRe(rule.pathGlob).test(input.relPath));
+        if (rule.content) {
+            try {
+                conditions.push(new RegExp(rule.content).test(input.content));
+            }
+            catch {
+                conditions.push(false);
+            }
+        }
+        if (conditions.length > 0 && conditions.every(Boolean)) {
+            findings.push({ ruleId: rule.id, message: rule.message, severity: rule.severity });
+        }
+    }
+    if (input.blockSecrets && isSecret) {
+        findings.push({
+            ruleId: "block-secrets",
+            message: "Writing to a secrets file is blocked by policy (guard.blockSecrets).",
+            severity: "block",
+        });
+    }
+    return { findings, block: findings.some((f) => f.severity === "block") };
+}
+// --- light description for map upkeep ---------------------------------------
+function describeLite(file, content) {
+    const ext = path.extname(file).toLowerCase();
+    const head = content.slice(0, 4096);
+    if (ext === ".md" || ext === ".mdx") {
+        const h = head.match(/^#{1,3}\s+(.+)$/m);
+        if (h)
+            return clip(h[1]);
+    }
+    for (const raw of head.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        const c = line.match(/^\s*(?:\/\/+|#+|--|;|\*)\s?(.+)$/);
+        if (c && c[1].trim().length > 3 && !/^[=*-]+$/.test(c[1].trim()))
+            return clip(c[1]);
+        break;
+    }
+    return "";
+}
+function clip(s, max = 90) {
+    const t = s.replace(/\s+/g, " ").trim();
+    return t.length > max ? t.slice(0, max - 1) + "…" : t;
+}
+function hookConfig() {
+    const raw = readJson(brainPath("config.json"), {});
+    return {
+        model: typeof raw?.model === "string" ? raw.model : "claude-opus-4-8",
+        extraSecretGlobs: Array.isArray(raw?.map?.extraSecretGlobs) ? raw.map.extraSecretGlobs : [],
+        blockSecrets: raw?.guard?.blockSecrets === true,
+        recallEnabled: raw?.recall?.enabled !== false,
+    };
+}
+// --- Claude Code hook IO ----------------------------------------------------
+function readStdin() {
+    return new Promise((resolve) => {
+        const chunks = [];
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            resolve(chunks.length ? Buffer.concat(chunks).toString("utf8") : "{}");
+        };
+        try {
+            process.stdin.on("data", (c) => chunks.push(Buffer.from(c)));
+            process.stdin.on("end", finish);
+            process.stdin.on("error", finish);
+        }
+        catch {
+            finish();
+        }
+        setTimeout(finish, 4000);
+    });
+}
+function parseInput(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function emitContext(event, text) {
+    if (!text)
+        return;
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: text } }));
+}
+/** PreToolUse deny (hard block) with a reason Claude sees. */
+function emitDeny(reason) {
+    process.stdout.write(JSON.stringify({
+        hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason },
+    }));
+}
+function newSession(id) {
+    return {
+        id,
+        started: new Date().toISOString(),
+        reads: {},
+        writes: [],
+        editCounts: {},
+        inputTokens: 0,
+        outputTokens: 0,
+        inputCost: 0,
+        outputCost: 0,
+        mapHits: 0,
+        mapMisses: 0,
+        dedupedReads: 0,
+    };
+}
+function readSession() {
+    return readJson(brainPath("state", "session.json"), null);
+}
+function writeSession(s) {
+    writeJson(brainPath("state", "session.json"), s);
+}
+// --- recall queue (zero-dep enqueue) ----------------------------------------
+function enqueueRecall(relPath) {
+    const q = readJson(brainPath("recall", "queue.json"), []);
+    if (!q.includes(relPath)) {
+        q.push(relPath);
+        writeJson(brainPath("recall", "queue.json"), q);
+    }
+}

package/dist/hooks/session-start.js

@@ -0,0 +1,72 @@
+"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 });
+const fs = __importStar(require("node:fs"));
+const runtime_js_1 = require("./runtime.js");
+function clearStale(dir) {
+    try {
+        for (const name of fs.readdirSync(dir)) {
+            if (name.endsWith(".tmp") || name.endsWith(".lock")) {
+                try {
+                    fs.rmSync(`${dir}/${name}`, { recursive: true, force: true });
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+    }
+    catch {
+        /* dir may not exist */
+    }
+}
+function main() {
+    (0, runtime_js_1.requireState)();
+    clearStale((0, runtime_js_1.brainPath)("hooks"));
+    clearStale((0, runtime_js_1.brainPath)("state"));
+    const now = new Date();
+    const id = `s-${now.toISOString().slice(0, 19).replace(/[:T]/g, "")}`;
+    (0, runtime_js_1.writeSession)((0, runtime_js_1.newSession)(id));
+    (0, runtime_js_1.appendLine)((0, runtime_js_1.brainPath)("journal.md"), `\n## ${id} — ${now.toISOString()}\n\n| Time | Action | File | Tokens |\n|------|--------|------|--------|\n`);
+    const parts = [];
+    const handoff = (0, runtime_js_1.readText)((0, runtime_js_1.brainPath)("handoff.md")).trim();
+    // Only surface a handoff that has real content (skip the seed placeholder).
+    if (handoff && !/no session recorded yet/i.test(handoff)) {
+        parts.push("Session handoff (where we left off):\n" + handoff);
+    }
+    parts.push("PackMind is active. Use the `recall` MCP tool to search project memory, and `record_solution`/`remember` to capture fixes and decisions. Check `.packmind/map.md` before reading files.");
+    (0, runtime_js_1.emitContext)("SessionStart", parts.join("\n\n"));
+}
+main();

package/dist/hooks/stop.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_js_1 = require("./runtime.js");
+async function main() {
+    (0, runtime_js_1.requireState)();
+    const session = (0, runtime_js_1.readSession)();
+    if (!session)
+        process.exit(0);
+    const reads = Object.keys(session.reads).length;
+    if (reads === 0 && session.writes.length === 0)
+        process.exit(0);
+    const cfg = (0, runtime_js_1.hookConfig)();
+    // Commit the session into the lifetime usage ledger (inline; hooks are dep-free).
+    const usagePath = (0, runtime_js_1.brainPath)("usage.json");
+    const ledger = (0, runtime_js_1.readJson)(usagePath, null);
+    if (ledger?.totals) {
+        ledger.sessions = ledger.sessions ?? [];
+        ledger.sessions.push({
+            id: session.id,
+            started: session.started,
+            ended: new Date().toISOString(),
+            inputTokens: session.inputTokens,
+            outputTokens: session.outputTokens,
+            inputCost: session.inputCost,
+            outputCost: session.outputCost,
+            reads,
+            writes: session.writes.length,
+        });
+        const t = ledger.totals;
+        t.inputTokens += session.inputTokens;
+        t.outputTokens += session.outputTokens;
+        t.inputCost += session.inputCost;
+        t.outputCost += session.outputCost;
+        t.reads += reads;
+        t.writes += session.writes.length;
+        t.sessions += 1;
+        t.dedupedReads += session.dedupedReads;
+        t.mapHits += session.mapHits;
+        (0, runtime_js_1.writeJson)(usagePath, ledger);
+    }
+    const turnCost = session.inputCost + session.outputCost;
+    (0, runtime_js_1.appendLine)((0, runtime_js_1.brainPath)("journal.md"), `\n> ${session.id}: ${reads} reads, ${session.writes.length} writes, ~$${turnCost.toFixed(4)} this turn.\n`);
+    // Regenerate the session handoff doc for cheap resume next time.
+    if (session.writes.length > 0) {
+        const recent = session.writes.slice(-12).map((w) => `- \`${w.file}\` (${w.action})`);
+        (0, runtime_js_1.writeText)((0, runtime_js_1.brainPath)("handoff.md"), [
+            "# Session Handoff",
+            "",
+            `_Updated ${new Date().toISOString()} · ${session.id}_`,
+            "",
+            "## Recently changed",
+            ...recent,
+            "",
+            "## Next steps",
+            "- (Capture what's left to do here, or via the `remember` MCP tool.)",
+            "",
+        ].join("\n"));
+    }
+    const reminders = [];
+    if (session.writes.length >= 3) {
+        reminders.push("Several files changed — record durable lessons/decisions with the `remember` tool and any fixes with `record_solution`.");
+    }
+    const heavy = Object.entries(session.editCounts).filter(([, n]) => n >= 4);
+    if (heavy.length) {
+        reminders.push(`Repeatedly edited ${heavy.map(([f]) => `\`${f}\``).join(", ")} — capture the root cause so it isn't rediscovered.`);
+    }
+    (0, runtime_js_1.emitContext)("Stop", reminders.join(" "));
+}
+main().catch(() => process.exit(0));