openwolf 1.0.0

package/dist/hooks/pre-write.js

@@ -0,0 +1,120 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getWolfDir, ensureWolfDir, readJSON, readMarkdown, readStdin } from "./shared.js";
+async function main() {
+    ensureWolfDir();
+    const wolfDir = getWolfDir();
+    const raw = await readStdin();
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch {
+        process.exit(0);
+        return;
+    }
+    // For Edit tool, the meaningful content is old_string + new_string
+    const content = input.tool_input?.content ?? "";
+    const oldStr = input.tool_input?.old_string ?? "";
+    const newStr = input.tool_input?.new_string ?? "";
+    const filePath = input.tool_input?.file_path ?? input.tool_input?.path ?? "";
+    const allContent = [content, oldStr, newStr].join("\n");
+    if (!allContent.trim()) {
+        process.exit(0);
+        return;
+    }
+    // 1. Cerebrum Do-Not-Repeat check
+    checkCerebrum(wolfDir, allContent);
+    // 2. Bug log: search for similar past bugs when editing code
+    // This fires when Claude is about to edit a file — if the edit looks like a fix
+    // (changing error handling, modifying catch blocks, etc.), check the bug log
+    if (filePath && (oldStr || content)) {
+        checkBugLog(wolfDir, filePath, oldStr, newStr, content);
+    }
+    process.exit(0);
+}
+function checkCerebrum(wolfDir, content) {
+    const cerebrumContent = readMarkdown(path.join(wolfDir, "cerebrum.md"));
+    const doNotRepeatSection = cerebrumContent.split("## Do-Not-Repeat")[1];
+    if (!doNotRepeatSection)
+        return;
+    const entries = doNotRepeatSection.split("## ")[0];
+    const lines = entries.split("\n").filter((l) => l.trim().startsWith("[") || l.trim().startsWith("-"));
+    for (const line of lines) {
+        const trimmed = line.trim().replace(/^[-*]\s*/, "").replace(/^\[[\d-]+\]\s*/, "");
+        if (!trimmed)
+            continue;
+        const patterns = [];
+        const quotedMatches = trimmed.match(/"([^"]+)"/g) || trimmed.match(/'([^']+)'/g) || trimmed.match(/`([^`]+)`/g);
+        if (quotedMatches) {
+            for (const qm of quotedMatches) {
+                patterns.push(qm.replace(/["'`]/g, ""));
+            }
+        }
+        const neverMatch = trimmed.match(/(?:never use|avoid|don't use|do not use)\s+(\w+)/i);
+        if (neverMatch)
+            patterns.push(neverMatch[1]);
+        for (const pattern of patterns) {
+            try {
+                const regex = new RegExp(`\\b${pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i");
+                if (regex.test(content)) {
+                    process.stderr.write(`⚠️ OpenWolf cerebrum warning: "${trimmed}" — check your code before proceeding.\n`);
+                }
+            }
+            catch { }
+        }
+    }
+}
+// Common words that appear in most code — must be excluded from similarity matching
+const STOP_WORDS = new Set([
+    "error", "function", "return", "const", "this", "that", "with", "from",
+    "import", "export", "class", "interface", "type", "undefined", "null",
+    "true", "false", "string", "number", "object", "array", "value",
+    "file", "path", "name", "data", "response", "request", "result",
+    "should", "must", "does", "have", "been", "will", "would", "could",
+    "when", "then", "else", "each", "some", "every", "only",
+]);
+function checkBugLog(wolfDir, filePath, oldStr, newStr, content) {
+    const bugLogPath = path.join(wolfDir, "buglog.json");
+    if (!fs.existsSync(bugLogPath))
+        return;
+    const bugLog = readJSON(bugLogPath, { version: 1, bugs: [] });
+    if (bugLog.bugs.length === 0)
+        return;
+    const basename = path.basename(filePath);
+    // ONLY surface bugs that match the SAME file being edited.
+    // Cross-file matching is too noisy and risks misdirecting Claude.
+    const fileMatches = bugLog.bugs.filter(b => {
+        const bugBasename = path.basename(b.file);
+        return bugBasename === basename;
+    });
+    if (fileMatches.length === 0)
+        return;
+    // Further filter: require tag or error_message overlap with the edit content
+    const editText = (oldStr + " " + newStr + " " + content).toLowerCase();
+    const editTokens = tokenize(editText);
+    const relevant = fileMatches.filter(bug => {
+        // Check if any bug tag appears in the edit content
+        const tagHit = bug.tags.some(t => editText.includes(t.toLowerCase()));
+        if (tagHit)
+            return true;
+        // Check meaningful word overlap (excluding stop words)
+        const bugTokens = tokenize(bug.error_message + " " + bug.root_cause);
+        const overlap = [...editTokens].filter(t => bugTokens.has(t));
+        // Require at least 3 meaningful overlapping words
+        return overlap.length >= 3;
+    });
+    if (relevant.length === 0)
+        return;
+    // Surface as a FYI, not a directive — Claude should evaluate, not blindly apply
+    process.stderr.write(`📋 OpenWolf buglog: ${relevant.length} past bug(s) found for ${basename} — review for context, do NOT apply blindly:\n`);
+    for (const bug of relevant.slice(0, 2)) {
+        process.stderr.write(`   [${bug.id}] "${bug.error_message.slice(0, 70)}"\n   Cause: ${bug.root_cause.slice(0, 80)}\n   Fix: ${bug.fix.slice(0, 80)}\n`);
+    }
+}
+function tokenize(text) {
+    return new Set(text.replace(/[^\w\s]/g, " ").split(/\s+/)
+        .filter(w => w.length > 3 && !STOP_WORDS.has(w.toLowerCase()))
+        .map(w => w.toLowerCase()));
+}
+main().catch(() => process.exit(0));

package/dist/hooks/session-start.js

@@ -0,0 +1,76 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getWolfDir, ensureWolfDir, writeJSON, appendMarkdown, readJSON, timestamp, timeShort } from "./shared.js";
+async function main() {
+    ensureWolfDir();
+    const wolfDir = getWolfDir();
+    // Clean up stale .tmp files left from failed atomic writes
+    try {
+        const files = fs.readdirSync(wolfDir);
+        for (const f of files) {
+            if (f.endsWith(".tmp")) {
+                try {
+                    fs.unlinkSync(path.join(wolfDir, f));
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    const hooksDir = path.join(wolfDir, "hooks");
+    const sessionFile = path.join(hooksDir, "_session.json");
+    const now = new Date();
+    const sessionId = `session-${now.toISOString().slice(0, 10)}-${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
+    // Create fresh session state
+    writeJSON(sessionFile, {
+        session_id: sessionId,
+        started: timestamp(),
+        files_read: {},
+        files_written: [],
+        edit_counts: {},
+        anatomy_hits: 0,
+        anatomy_misses: 0,
+        repeated_reads_warned: 0,
+        cerebrum_warnings: 0,
+        stop_count: 0,
+    });
+    // Append session header to memory.md
+    const memoryPath = path.join(wolfDir, "memory.md");
+    const header = `\n## Session: ${now.toISOString().slice(0, 10)} ${timeShort()}\n\n| Time | Action | File(s) | Outcome | ~Tokens |\n|------|--------|---------|---------|--------|\n`;
+    appendMarkdown(memoryPath, header);
+    // Check cerebrum freshness — remind Claude to learn
+    try {
+        const cerebrumPath = path.join(wolfDir, "cerebrum.md");
+        const cerebrumContent = fs.readFileSync(cerebrumPath, "utf-8");
+        const stat = fs.statSync(cerebrumPath);
+        const daysSinceUpdate = (Date.now() - stat.mtimeMs) / (1000 * 60 * 60 * 24);
+        // Count actual entries (non-comment, non-empty lines in content sections)
+        const entryLines = cerebrumContent.split("\n").filter(l => {
+            const t = l.trim();
+            return t.startsWith("- ") || t.startsWith("* ") || (t.startsWith("[") && t.includes("]"));
+        });
+        if (entryLines.length < 3) {
+            process.stderr.write(`💡 OpenWolf: cerebrum.md has only ${entryLines.length} entries. Learn from this session — record user preferences, project conventions, and mistakes to .wolf/cerebrum.md.\n`);
+        }
+        else if (daysSinceUpdate > 3) {
+            process.stderr.write(`💡 OpenWolf: cerebrum.md hasn't been updated in ${Math.floor(daysSinceUpdate)} days. Look for opportunities to add learnings this session.\n`);
+        }
+    }
+    catch { }
+    // Check buglog — remind if empty
+    try {
+        const buglogPath = path.join(wolfDir, "buglog.json");
+        const buglog = readJSON(buglogPath, { bugs: [] });
+        if (buglog.bugs.length === 0) {
+            process.stderr.write(`📋 OpenWolf: buglog.json is empty. If you encounter or fix any bugs, errors, or failed tests this session, log them to .wolf/buglog.json.\n`);
+        }
+    }
+    catch { }
+    // Increment total_sessions in token-ledger
+    const ledgerPath = path.join(wolfDir, "token-ledger.json");
+    const ledger = readJSON(ledgerPath, { version: 1, lifetime: { total_sessions: 0 } });
+    ledger.lifetime.total_sessions++;
+    writeJSON(ledgerPath, ledger);
+    process.exit(0);
+}
+main().catch(() => process.exit(0));