openwolf-enhanced 1.9.3

package/dist/hooks/pre-read.js

@@ -0,0 +1,107 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getWolfDir, ensureWolfDir, readJSON, writeJSON, readMarkdown, parseAnatomy, readStdin, normalizePath, loadIgnore } from "./shared.js";
+async function main() {
+    ensureWolfDir();
+    const wolfDir = getWolfDir();
+    const hooksDir = path.join(wolfDir, "hooks");
+    const sessionFile = path.join(hooksDir, "_session.json");
+    const raw = await readStdin();
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch {
+        process.exit(0);
+        return;
+    }
+    const filePath = input.tool_input?.file_path ?? input.tool_input?.path ?? "";
+    if (!filePath) {
+        process.exit(0);
+        return;
+    }
+    const normalizedFile = normalizePath(filePath);
+    // Current on-disk mtime (used to allow a legitimate re-read after the file changed).
+    let fileMtime;
+    try {
+        fileMtime = fs.statSync(filePath).mtimeMs;
+    }
+    catch { /* not statable */ }
+    // Skip tracking for .wolf/ internal files — they're infrastructure, not project files.
+    // Counting them inflates anatomy miss rates since .wolf/ is excluded from anatomy scanning.
+    const projectDir = normalizePath(process.env.CLAUDE_PROJECT_DIR || process.cwd());
+    const relToProject = normalizedFile.startsWith(projectDir)
+        ? normalizedFile.slice(projectDir.length).replace(/^\//, "")
+        : "";
+    // Don't track files outside the project root (upstream #56).
+    if (!relToProject) {
+        process.exit(0);
+        return;
+    }
+    if (relToProject.startsWith(".wolf/") || relToProject.startsWith(".wolf\\")) {
+        process.exit(0);
+        return;
+    }
+    // Skip .gitignore / .wolfignore matches — no anatomy hint / repeated-read tracking for them.
+    if (loadIgnore(projectDir)(relToProject)) {
+        process.exit(0);
+        return;
+    }
+    const session = readJSON(sessionFile, {
+        session_id: "", files_read: {}, anatomy_hits: 0, anatomy_misses: 0,
+        repeated_reads_warned: 0,
+    });
+    // Check if already read this session
+    if (session.files_read[normalizedFile]) {
+        const prev = session.files_read[normalizedFile];
+        // If the file changed since we last read it (e.g. it was edited during the session),
+        // a re-read is legitimate — refresh state and don't warn about a repeated read (upstream #41).
+        if (fileMtime !== undefined && prev.mtime !== undefined && fileMtime !== prev.mtime) {
+            prev.count++;
+            prev.mtime = fileMtime;
+            writeJSON(sessionFile, session);
+            process.exit(0);
+            return;
+        }
+        process.stderr.write(`⚡ OpenWolf: ${path.basename(normalizedFile)} was already read this session (~${prev.tokens} tokens). Consider using your existing knowledge of this file.\n`);
+        prev.count++;
+        prev.mtime = fileMtime ?? prev.mtime;
+        session.repeated_reads_warned++;
+        writeJSON(sessionFile, session);
+        process.exit(0);
+        return;
+    }
+    // Check anatomy.md for this file
+    const anatomyContent = readMarkdown(path.join(wolfDir, "anatomy.md"));
+    const sections = parseAnatomy(anatomyContent);
+    let found = false;
+    for (const [sectionKey, entries] of sections) {
+        for (const entry of entries) {
+            // Build the full relative path from the section key + filename for accurate matching
+            const entryRelPath = normalizePath(path.join(sectionKey, entry.file));
+            if (normalizedFile.endsWith(entryRelPath) || normalizedFile.endsWith("/" + entryRelPath)) {
+                process.stderr.write(`📋 OpenWolf anatomy: ${entry.file} — ${entry.description} (~${entry.tokens} tok)\n`);
+                found = true;
+                break;
+            }
+        }
+        if (found)
+            break;
+    }
+    if (found) {
+        session.anatomy_hits++;
+    }
+    else {
+        session.anatomy_misses++;
+    }
+    // Record initial read entry (tokens will be updated in post-read)
+    session.files_read[normalizedFile] = {
+        count: 1,
+        tokens: 0,
+        first_read: new Date().toISOString(),
+        mtime: fileMtime,
+    };
+    writeJSON(sessionFile, session);
+    process.exit(0);
+}
+main().catch(() => process.exit(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, readMarkdown, readStdin, readBugLog } 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 = readBugLog(wolfDir); // tolerates legacy array format
+    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));

package/dist/hooks/stop.js

@@ -0,0 +1,219 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getWolfDir, ensureWolfDir, readJSON, writeJSON, appendMarkdown, timeShort, getRetention, compactMemoryIfLarge, countSemanticEntries, withLock } from "./shared.js";
+async function main() {
+    ensureWolfDir();
+    const wolfDir = getWolfDir();
+    const hooksDir = path.join(wolfDir, "hooks");
+    const sessionFile = path.join(hooksDir, "_session.json");
+    const session = readJSON(sessionFile, {
+        session_id: "",
+        started: "",
+        files_read: {},
+        files_written: [],
+        edit_counts: {},
+        anatomy_hits: 0,
+        anatomy_misses: 0,
+        repeated_reads_warned: 0,
+        cerebrum_warnings: 0,
+        stop_count: 0,
+    });
+    session.stop_count++;
+    // Only write to ledger if there's been activity
+    const readCount = Object.keys(session.files_read).length;
+    const writeCount = session.files_written.length;
+    if (readCount === 0 && writeCount === 0) {
+        writeJSON(sessionFile, session);
+        process.exit(0);
+        return;
+    }
+    // Collect end-of-turn reminders. These are surfaced via additionalContext (stdout) at the
+    // very end so they land in Claude's next context window — stderr would only hit the terminal.
+    // Each reminder type fires at most once per session so it doesn't re-nag every turn.
+    const candidates = [
+        { key: "buglog", msg: checkForMissingBugLogs(wolfDir, session) },
+        { key: "cerebrum", msg: checkCerebrumFreshness(wolfDir, session) },
+        { key: "summary", msg: checkSemanticSummaries(wolfDir, writeCount) },
+        { key: "status", msg: checkStatusFreshness(wolfDir, session) },
+    ].filter((c) => c.msg !== null);
+    const alreadyShown = new Set(session.reminders_shown ?? []);
+    const fresh = candidates.filter((c) => !alreadyShown.has(c.key));
+    for (const c of fresh)
+        alreadyShown.add(c.key);
+    session.reminders_shown = [...alreadyShown];
+    const reminders = fresh.map((c) => c.msg);
+    // Build session entry for ledger
+    const reads = Object.entries(session.files_read).map(([file, data]) => ({
+        file,
+        tokens_estimated: data.tokens,
+        was_repeated: data.count > 1,
+        anatomy_had_description: false, // simplified
+    }));
+    const writes = session.files_written.map((w) => ({
+        file: w.file,
+        tokens_estimated: w.tokens,
+        action: w.action,
+    }));
+    const inputTokens = reads.reduce((sum, r) => sum + r.tokens_estimated, 0);
+    const outputTokens = writes.reduce((sum, w) => sum + w.tokens_estimated, 0);
+    const sessionEntry = {
+        id: session.session_id,
+        started: session.started,
+        ended: new Date().toISOString(),
+        reads,
+        writes,
+        totals: {
+            input_tokens_estimated: inputTokens,
+            output_tokens_estimated: outputTokens,
+            reads_count: readCount,
+            writes_count: writeCount,
+            repeated_reads_blocked: session.repeated_reads_warned,
+            anatomy_lookups: session.anatomy_hits,
+        },
+    };
+    // Update token-ledger.json — lock the read-modify-write so concurrent sessions and the cron
+    // token report don't clobber each other (M1).
+    const ret = getRetention(wolfDir);
+    const ledgerPath = path.join(wolfDir, "token-ledger.json");
+    withLock(ledgerPath, () => {
+        const ledger = readJSON(ledgerPath, {
+            version: 1,
+            created_at: "",
+            lifetime: {
+                total_tokens_estimated: 0,
+                total_reads: 0,
+                total_writes: 0,
+                total_sessions: 0,
+                anatomy_hits: 0,
+                anatomy_misses: 0,
+                repeated_reads_blocked: 0,
+                estimated_savings_vs_bare_cli: 0,
+            },
+            sessions: [],
+            daemon_usage: [],
+            waste_flags: [],
+            optimization_report: { last_generated: null, patterns: [] },
+        });
+        // Keep token-ledger.json bounded: cap per-session arrays and total session count.
+        // Without this, sessions[] (each embedding full reads[]/writes[]) grows without limit
+        // and writeJSON's full-file rewrite becomes quadratic over time. Limits are tunable
+        // via config.json openwolf.retention.
+        if (Array.isArray(sessionEntry.reads) && sessionEntry.reads.length > ret.session_io_max) {
+            sessionEntry.reads = sessionEntry.reads.slice(-ret.session_io_max);
+        }
+        if (Array.isArray(sessionEntry.writes) && sessionEntry.writes.length > ret.session_io_max) {
+            sessionEntry.writes = sessionEntry.writes.slice(-ret.session_io_max);
+        }
+        ledger.sessions.push(sessionEntry);
+        if (ledger.sessions.length > ret.token_ledger_max_sessions) {
+            ledger.sessions = ledger.sessions.slice(-ret.token_ledger_max_sessions);
+        }
+        ledger.lifetime.total_reads += readCount;
+        ledger.lifetime.total_writes += writeCount;
+        ledger.lifetime.total_tokens_estimated += inputTokens + outputTokens;
+        ledger.lifetime.anatomy_hits += session.anatomy_hits;
+        ledger.lifetime.anatomy_misses += session.anatomy_misses;
+        ledger.lifetime.repeated_reads_blocked += session.repeated_reads_warned;
+        // Estimate savings: anatomy hits save ~200 tokens each, repeated reads blocked save their token count
+        const savedFromAnatomy = session.anatomy_hits * 200;
+        const savedFromRepeats = Object.values(session.files_read)
+            .filter((r) => r.count > 1)
+            .reduce((sum, r) => sum + r.tokens * (r.count - 1), 0);
+        ledger.lifetime.estimated_savings_vs_bare_cli += savedFromAnatomy + savedFromRepeats;
+        writeJSON(ledgerPath, ledger);
+    });
+    // Write a session summary line to memory.md if there was meaningful activity
+    if (writeCount > 0) {
+        try {
+            const uniqueFiles = new Set(session.files_written.map(w => path.basename(w.file)));
+            const fileList = [...uniqueFiles].slice(0, 5).join(", ");
+            const memoryPath = path.join(wolfDir, "memory.md");
+            appendMarkdown(memoryPath, `| ${timeShort()} | Session end: ${writeCount} writes across ${uniqueFiles.size} files (${fileList}) | ${readCount} reads | ~${inputTokens + outputTokens} tok |\n`);
+        }
+        catch { }
+    }
+    // Opportunistic self-maintenance: keep memory.md bounded even when the daemon
+    // (which normally runs the consolidation cron) isn't running. Stat-gated → cheap.
+    try {
+        compactMemoryIfLarge(wolfDir, ret.memory_max_bytes);
+    }
+    catch { }
+    writeJSON(sessionFile, session);
+    // Surface reminders into Claude's next context window (Stop hooks can inject via stdout JSON).
+    if (reminders.length > 0) {
+        const additionalContext = `⚠️ OpenWolf end-of-turn reminders:\n${reminders.map((r) => `• ${r}`).join("\n")}`;
+        process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "Stop", additionalContext } }));
+    }
+    process.exit(0);
+}
+/**
+ * Check if files were edited multiple times but buglog.json wasn't updated.
+ * Emit a stderr reminder so Claude sees it in the next turn.
+ */
+function checkForMissingBugLogs(wolfDir, session) {
+    if (!session.edit_counts)
+        return null;
+    const multiEditFiles = Object.entries(session.edit_counts)
+        .filter(([, count]) => count >= 3)
+        .map(([file]) => path.basename(file));
+    if (multiEditFiles.length === 0)
+        return null;
+    // Check if buglog was written to this session
+    const buglogWritten = session.files_written.some(w => w.file.includes("buglog.json"));
+    if (!buglogWritten) {
+        return `Files edited 3+ times this session (${multiEditFiles.join(", ")}) but buglog.json was not updated. If you fixed bugs, log them to .wolf/buglog.json.`;
+    }
+    return null;
+}
+/**
+ * Check if cerebrum.md was updated recently. If it hasn't been updated in
+ * a while and there was significant activity, return a gentle reminder.
+ */
+function checkCerebrumFreshness(wolfDir, session) {
+    const cerebrumPath = path.join(wolfDir, "cerebrum.md");
+    try {
+        const stat = fs.statSync(cerebrumPath);
+        const hoursSinceUpdate = (Date.now() - stat.mtimeMs) / (1000 * 60 * 60);
+        // If cerebrum hasn't been updated in 24h+ and there were significant writes
+        if (hoursSinceUpdate > 24 && session.files_written.length >= 3) {
+            return `cerebrum.md hasn't been updated in ${Math.floor(hoursSinceUpdate)}h. Did you learn any user preferences, conventions, or gotchas this session? Consider updating .wolf/cerebrum.md.`;
+        }
+    }
+    catch {
+        // cerebrum.md doesn't exist, that's ok
+    }
+    return null;
+}
+/**
+ * If STATUS.md is older than the session start (or missing) and there was meaningful code
+ * activity, nudge Claude to update the handoff doc so the next /clear resumes cheaply. (upstream #40)
+ */
+function checkStatusFreshness(wolfDir, session) {
+    const statusPath = path.join(wolfDir, "STATUS.md");
+    const codeWrites = session.files_written.filter((w) => !w.file.includes("/.wolf/") && !w.file.endsWith(".tmp"));
+    if (codeWrites.length < 3)
+        return null;
+    try {
+        const stat = fs.statSync(statusPath);
+        const sessionStartMs = session.started ? Date.parse(session.started) : 0;
+        if (sessionStartMs && stat.mtimeMs < sessionStartMs) {
+            return `STATUS.md wasn't updated this session despite ${codeWrites.length} code writes. Update .wolf/STATUS.md (✅ done / 🚀 next quest) before /clear so the next session resumes in one read.`;
+        }
+    }
+    catch {
+        return `.wolf/STATUS.md is missing. Create it with the current quest summary + next steps so /clear stays cheap.`;
+    }
+    return null;
+}
+/**
+ * If there were meaningful edits this session but no non-mechanical memory.md summary
+ * was written, nudge Claude to record what it did. (upstream #55)
+ */
+function checkSemanticSummaries(wolfDir, writeCount) {
+    if (writeCount < 3)
+        return null;
+    if (countSemanticEntries(wolfDir) > 0)
+        return null;
+    return `${writeCount} files were changed this session but no meaningful summary was written to memory.md. Consider recording what you did and why.`;
+}
+main().catch(() => process.exit(0));

package/dist/src/buglog/bug-matcher.js

@@ -0,0 +1,3 @@
+// Re-export from bug-tracker for convenience
+export { findSimilarBugs, searchBugs } from "./bug-tracker.js";
+//# sourceMappingURL=bug-matcher.js.map

package/dist/src/buglog/bug-matcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bug-matcher.js","sourceRoot":"","sources":["../../../src/buglog/bug-matcher.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/src/buglog/bug-tracker.js

@@ -0,0 +1,89 @@
+import * as path from "node:path";
+import { readJSON, writeJSON } from "../utils/fs-safe.js";
+export function getBugLogPath(wolfDir) {
+    return path.join(wolfDir, "buglog.json");
+}
+export function readBugLog(wolfDir) {
+    return readJSON(getBugLogPath(wolfDir), { version: 1, bugs: [] });
+}
+export function logBug(wolfDir, bug) {
+    const bugLog = readBugLog(wolfDir);
+    const now = new Date().toISOString();
+    // Check for near-duplicate (score > 0.8)
+    const similar = findSimilarBugs(wolfDir, bug.error_message);
+    if (similar.length > 0 && similar[0].score > 0.8) {
+        const existing = bugLog.bugs.find((b) => b.id === similar[0].bug.id);
+        if (existing) {
+            existing.occurrences++;
+            existing.last_seen = now;
+            writeJSON(getBugLogPath(wolfDir), bugLog);
+            return;
+        }
+    }
+    const id = `bug-${String(bugLog.bugs.length + 1).padStart(3, "0")}`;
+    bugLog.bugs.push({
+        id,
+        timestamp: now,
+        error_message: bug.error_message,
+        file: bug.file,
+        line: bug.line,
+        root_cause: bug.root_cause,
+        fix: bug.fix,
+        tags: bug.tags,
+        related_bugs: [],
+        occurrences: 1,
+        last_seen: now,
+    });
+    writeJSON(getBugLogPath(wolfDir), bugLog);
+}
+function normalize(text) {
+    // Tolerate entries missing fields (legacy / auto-detected / schema drift) — upstream #44.
+    return String(text ?? "").toLowerCase().replace(/\d+/g, "N").replace(/[^\w\s]/g, " ").trim();
+}
+function tokenize(text) {
+    return new Set(normalize(text).split(/\s+/).filter((w) => w.length > 2));
+}
+function jaccardSimilarity(a, b) {
+    const intersection = new Set([...a].filter((x) => b.has(x)));
+    const union = new Set([...a, ...b]);
+    return union.size === 0 ? 0 : intersection.size / union.size;
+}
+export function findSimilarBugs(wolfDir, errorMessage) {
+    const bugLog = readBugLog(wolfDir);
+    const normalizedInput = normalize(errorMessage);
+    const inputTokens = tokenize(errorMessage);
+    const results = [];
+    for (const bug of bugLog.bugs) {
+        let score = 0;
+        // Exact substring match
+        if (normalize(bug.error_message).includes(normalizedInput) ||
+            normalizedInput.includes(normalize(bug.error_message))) {
+            score += 1.0;
+        }
+        // Word overlap (jaccard)
+        const bugTokens = tokenize(bug.error_message);
+        score += jaccardSimilarity(inputTokens, bugTokens) * 0.5;
+        if (score > 0.3) {
+            results.push({ bug, score });
+        }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}
+export function searchBugs(wolfDir, term) {
+    const bugLog = readBugLog(wolfDir);
+    const lower = term.toLowerCase();
+    // Null-safe across schema drift: any entry may miss a field, `tags` may be absent,
+    // and some tooling records `files: string[]` instead of a singular `file` (upstream #44).
+    const has = (v) => typeof v === "string" && v.toLowerCase().includes(lower);
+    return bugLog.bugs.filter((b) => {
+        const bug = b;
+        const files = Array.isArray(bug.files) ? bug.files : bug.file != null ? [bug.file] : [];
+        return (has(bug.error_message) ||
+            has(bug.root_cause) ||
+            has(bug.fix) ||
+            (Array.isArray(bug.tags) && bug.tags.some((t) => has(t))) ||
+            files.some((f) => has(f)));
+    });
+}
+//# sourceMappingURL=bug-tracker.js.map

package/dist/src/buglog/bug-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bug-tracker.js","sourceRoot":"","sources":["../../../src/buglog/bug-tracker.ts"],"names":[],"mappings":"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"}

package/dist/src/cli/bug-cmd.js

@@ -0,0 +1,31 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { findProjectRoot } from "../scanner/project-root.js";
+import { searchBugs } from "../buglog/bug-tracker.js";
+export function bugSearch(term) {
+    const projectRoot = findProjectRoot();
+    const wolfDir = path.join(projectRoot, ".wolf");
+    if (!fs.existsSync(wolfDir)) {
+        console.log("OpenWolf not initialized. Run: openwolf init");
+        return;
+    }
+    const results = searchBugs(wolfDir, term);
+    if (results.length === 0) {
+        console.log(`No bugs found matching "${term}".`);
+        return;
+    }
+    console.log(`Found ${results.length} matching bug(s):\n`);
+    for (const b of results) {
+        // Null-safe display: entries can be missing fields or use files[] (schema drift, #44).
+        const bug = b;
+        const files = Array.isArray(bug.files) ? bug.files.join(", ") : (bug.file ?? "—");
+        console.log(`  [${bug.id ?? "?"}] ${(bug.error_message ?? "(no message)").slice(0, 80)}`);
+        console.log(`    File: ${files}${bug.line ? `:${bug.line}` : ""}`);
+        console.log(`    Root cause: ${bug.root_cause ?? "—"}`);
+        console.log(`    Fix: ${bug.fix ?? "—"}`);
+        console.log(`    Tags: ${Array.isArray(bug.tags) ? bug.tags.filter(Boolean).join(", ") : "—"}`);
+        console.log(`    Occurrences: ${bug.occurrences ?? 1} | Last seen: ${bug.last_seen ?? "—"}`);
+        console.log("");
+    }
+}
+//# sourceMappingURL=bug-cmd.js.map

package/dist/src/cli/bug-cmd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bug-cmd.js","sourceRoot":"","sources":["../../../src/cli/bug-cmd.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEtD,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,MAAM,WAAW,GAAG,eAAe,EAAE,CAAC;IACtC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAEhD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5B,OAAO,CAAC,GAAG,CAAC,8CAA8C,CAAC,CAAC;QAC5D,OAAO;IACT,CAAC;IAED,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAE1C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,CAAC,GAAG,CAAC,2BAA2B,IAAI,IAAI,CAAC,CAAC;QACjD,OAAO;IACT,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,SAAS,OAAO,CAAC,MAAM,qBAAqB,CAAC,CAAC;IAE1D,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,uFAAuF;QACvF,MAAM,GAAG,GAAG,CAAoC,CAAC;QACjD,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC;QAClF,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,aAAa,IAAI,cAAc,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QAC1F,OAAO,CAAC,GAAG,CAAC,aAAa,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACnE,OAAO,CAAC,GAAG,CAAC,mBAAmB,GAAG,CAAC,UAAU,IAAI,GAAG,EAAE,CAAC,CAAC;QACxD,OAAO,CAAC,GAAG,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,GAAG,EAAE,CAAC,CAAC;QAC1C,OAAO,CAAC,GAAG,CAAC,aAAa,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;QAChG,OAAO,CAAC,GAAG,CAAC,oBAAoB,GAAG,CAAC,WAAW,IAAI,CAAC,iBAAiB,GAAG,CAAC,SAAS,IAAI,GAAG,EAAE,CAAC,CAAC;QAC7F,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAClB,CAAC;AACH,CAAC"}