@bolloon/bolloon-agent 0.1.1 → 0.1.3

package/dist/bollharness/src/scripts/hooks/gate-judgment-inject.js

@@ -0,0 +1,92 @@
+import * as fs from "fs";
+import * as path from "path";
+const REPO_ROOT = process.cwd();
+function getCurrentGate() {
+    const envGate = process.env.BOLL_GATE_TO;
+    if (envGate) {
+        return parseInt(envGate, 10);
+    }
+    try {
+        const gateFile = path.join(REPO_ROOT, ".boll", "gate", "current");
+        if (fs.existsSync(gateFile)) {
+            const content = fs.readFileSync(gateFile, "utf-8").trim();
+            const state = JSON.parse(content);
+            return state.current_gate;
+        }
+    }
+    catch { }
+    const envGateFinal = process.env.BOLL_GATE;
+    if (envGateFinal) {
+        return parseInt(envGateFinal, 10);
+    }
+    return 0;
+}
+async function getCoreJudgments() {
+    try {
+        const judgmentPath = path.join(REPO_ROOT, "src", "bollharness-integration", "context-router-judgment.js");
+        if (!fs.existsSync(judgmentPath)) {
+            return "";
+        }
+        const { getCoreJudgmentsForSession } = await import(judgmentPath);
+        return await getCoreJudgmentsForSession(0.9);
+    }
+    catch (e) {
+        console.error("[Gate Judgment] Failed to load core judgments:", e);
+        return "";
+    }
+}
+async function getGateJudgments(gate) {
+    try {
+        const judgmentPath = path.join(REPO_ROOT, "src", "bollharness-integration", "context-router-judgment.js");
+        if (!fs.existsSync(judgmentPath)) {
+            return "";
+        }
+        const { generateJudgmentInjection } = await import(judgmentPath);
+        return await generateJudgmentInjection(".", gate);
+    }
+    catch (e) {
+        console.error("[Gate Judgment] Failed to load gate judgments:", e);
+        return "";
+    }
+}
+async function getContextChainInjection(gate) {
+    try {
+        const chainPath = path.join(REPO_ROOT, "src", "bollharness-integration", "context-chain-router.js");
+        if (!fs.existsSync(chainPath)) {
+            return "";
+        }
+        const { generateContextChainInjection } = await import(chainPath);
+        return await generateContextChainInjection(gate);
+    }
+    catch (e) {
+        console.error("[Gate Judgment] Failed to load context chains:", e);
+        return "";
+    }
+}
+export async function main() {
+    const gate = getCurrentGate();
+    const INJECT_GATES = [0, 3];
+    if (!INJECT_GATES.includes(gate)) {
+        process.exit(0);
+    }
+    const judgments = gate === 0
+        ? await getCoreJudgments()
+        : await getGateJudgments(gate);
+    const chains = await getContextChainInjection(gate);
+    if (judgments || chains) {
+        process.stdout.write("\n");
+        if (judgments) {
+            process.stdout.write(judgments + "\n\n");
+        }
+        if (chains) {
+            process.stdout.write(chains + "\n");
+        }
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main().catch((e) => {
+        console.error("[Gate Judgment] Error:", e);
+        process.exit(1);
+    });
+}

package/dist/bollharness/src/scripts/hooks/gate-transition-judgment.js

@@ -0,0 +1,63 @@
+import * as fs from "fs";
+import * as path from "path";
+const REPO_ROOT = process.cwd();
+async function getGateJudgments(gate, filePath = ".") {
+    try {
+        const judgmentPath = path.join(REPO_ROOT, "src", "bollharness-integration", "context-router-judgment.js");
+        if (!fs.existsSync(judgmentPath)) {
+            return "";
+        }
+        const { generateJudgmentInjection } = await import(judgmentPath);
+        return await generateJudgmentInjection(filePath, gate);
+    }
+    catch (e) {
+        console.error("[Gate Transition Judgment] Failed to load judgments:", e);
+        return "";
+    }
+}
+async function getContextChainInjection(gate) {
+    try {
+        const chainPath = path.join(REPO_ROOT, "src", "bollharness-integration", "context-chain-router.js");
+        if (!fs.existsSync(chainPath)) {
+            return "";
+        }
+        const { generateContextChainInjection } = await import(chainPath);
+        return await generateContextChainInjection(gate);
+    }
+    catch (e) {
+        console.error("[Gate Transition Judgment] Failed to load context chains:", e);
+        return "";
+    }
+}
+export async function main() {
+    const args = process.argv.slice(2);
+    const envGate = process.env.BOLL_GATE_TO;
+    const gate = args[0]
+        ? parseInt(args[0], 10)
+        : envGate
+            ? parseInt(envGate, 10)
+            : 0;
+    const filePath = args[1] || ".";
+    const INJECT_GATES = [0, 3];
+    if (!INJECT_GATES.includes(gate)) {
+        process.exit(0);
+    }
+    const judgments = await getGateJudgments(gate, filePath);
+    const chains = await getContextChainInjection(gate);
+    if (judgments || chains) {
+        process.stdout.write("\n");
+        if (judgments) {
+            process.stdout.write(judgments + "\n\n");
+        }
+        if (chains) {
+            process.stdout.write(chains + "\n");
+        }
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main().catch((e) => {
+        console.error("[Gate Transition Judgment] Error:", e);
+        process.exit(1);
+    });
+}

package/dist/bollharness/src/scripts/hooks/inbox-ack.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/inbox-inject-on-start.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/inbox-validate.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/inbox-write-ledger.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/initializer-agent.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/loop-detection.js

@@ -0,0 +1,73 @@
+import * as fs from "fs";
+import * as path from "path";
+const LOOP_THRESHOLD = 5;
+const STATE_DIR = ".boll/guard";
+const STATE_FILE_PREFIX = "loop-";
+const TTL_SECONDS = 3600;
+function getStateFile() {
+    const pid = process.ppid;
+    return path.join(STATE_DIR, `${STATE_FILE_PREFIX}${pid}.json`);
+}
+function loadState() {
+    const stateFile = getStateFile();
+    if (!fs.existsSync(stateFile))
+        return {};
+    try {
+        const data = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
+        if (Date.now() / 1000 - data._ts > TTL_SECONDS) {
+            return {};
+        }
+        return data;
+    }
+    catch (exc) {
+        process.stderr.write(`[loop-detection] corrupt state ${stateFile}: ${exc}; resetting\n`);
+        try {
+            fs.unlinkSync(stateFile);
+        }
+        catch { }
+        return {};
+    }
+}
+function saveState(state) {
+    try {
+        if (!fs.existsSync(STATE_DIR)) {
+            fs.mkdirSync(STATE_DIR, { recursive: true });
+        }
+        state._ts = Date.now() / 1000;
+        fs.writeFileSync(getStateFile(), JSON.stringify(state), "utf-8");
+    }
+    catch (exc) {
+        process.stderr.write(`[loop-detection] save_state OSError: ${exc}; counter not persisted\n`);
+    }
+}
+export function postToolUseInject(message) {
+    process.stdout.write(`\n\n## Loop Detection\n\n${message}\n`);
+}
+export function main() {
+    let event;
+    try {
+        event = JSON.parse(fs.readFileSync(0, "utf-8") || "{}");
+    }
+    catch {
+        return;
+    }
+    const toolName = event.tool_name || "";
+    const toolInput = event.tool_input || {};
+    if (!["Write", "Edit"].includes(toolName))
+        return;
+    const filePath = toolInput.file_path || "";
+    if (!filePath)
+        return;
+    const state = loadState();
+    const counts = state.counts || {};
+    counts[filePath] = (counts[filePath] || 0) + 1;
+    state.counts = counts;
+    saveState(state);
+    const count = counts[filePath];
+    if (count >= LOOP_THRESHOLD) {
+        postToolUseInject(`[LoopDetection] 你已经编辑 ${filePath} ${count} 次了。考虑换一个方法或退一步重新思考整体方案。[来源: LangChain LoopDetection middleware]`);
+    }
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/owner-guard.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/precompact.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/review-agent-gatekeeper.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/risk-tracker.js

@@ -0,0 +1,108 @@
+import * as fs from "fs";
+import * as path from "path";
+const REPO_ROOT = process.cwd();
+const STATE_FILE = path.join(REPO_ROOT, ".boll", "state", "risk-snapshot.json");
+const RISK_ORDER = { R0: 0, R1: 1, R2: 2, R3: 3, R4: 4 };
+const RISK_ELEVATORS = [
+    ["scripts/deploy", "R4"],
+    ["backend/product/db/migration", "R4"],
+    ["CLAUDE.md", "R3"],
+    [".boll/settings.json", "R3"],
+    [".boll/skills/", "R3"],
+    [".boll/rules/", "R3"],
+    [".boll/agents/", "R3"],
+    ["scripts/hooks/", "R3"],
+    ["scripts/checks/", "R3"],
+    [".github/", "R3"],
+    ["backend/product/routes/", "R2"],
+    ["backend/product/config.py", "R2"],
+    ["backend/server.py", "R2"],
+    ["docs/decisions/ADR-", "R2"],
+    ["mcp-server/", "R2"],
+    ["mcp-server-node/", "R2"],
+    ["website/app/", "R2"],
+];
+function readPayload() {
+    try {
+        const raw = fs.readFileSync(0, "utf-8");
+        return raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function loadSnapshot() {
+    if (fs.existsSync(STATE_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(STATE_FILE, "utf-8"));
+        }
+        catch { }
+    }
+    return {
+        risk_level: "R0",
+        risk_sources: [],
+        ratchet_locked: false,
+        files_touched: [],
+    };
+}
+function saveSnapshot(snap) {
+    const dir = path.dirname(STATE_FILE);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(STATE_FILE, JSON.stringify(snap, null, 2) + "\n", "utf-8");
+}
+function classifyFile(filePath) {
+    for (const [pattern, risk] of RISK_ELEVATORS) {
+        if (filePath.startsWith(pattern))
+            return risk;
+    }
+    return "R0";
+}
+export function main() {
+    const payload = readPayload();
+    const toolInput = payload.tool_input || {};
+    const filePath = toolInput.file_path || "";
+    if (!filePath)
+        return;
+    let relPath;
+    try {
+        relPath = path.relative(REPO_ROOT, filePath);
+    }
+    catch {
+        relPath = filePath;
+    }
+    const fileRisk = classifyFile(relPath);
+    const snap = loadSnapshot();
+    const currentLevel = snap.risk_level || "R0";
+    const currentOrder = RISK_ORDER[currentLevel] ?? 0;
+    const newOrder = RISK_ORDER[fileRisk] ?? 0;
+    const filesTouched = snap.files_touched || [];
+    if (!filesTouched.includes(relPath)) {
+        filesTouched.push(relPath);
+    }
+    let finalRisk = fileRisk;
+    let finalOrder = newOrder;
+    if (filesTouched.length >= 4 && currentOrder < RISK_ORDER.R1) {
+        finalRisk = "R1";
+        finalOrder = RISK_ORDER.R1;
+    }
+    if (finalOrder > currentOrder) {
+        snap.risk_level = finalRisk;
+        snap.ratchet_locked = true;
+        const sources = snap.risk_sources || [];
+        sources.push({
+            type: "path",
+            value: relPath,
+            elevated_to: finalRisk,
+            ts: new Date().toISOString(),
+        });
+        snap.risk_sources = sources;
+    }
+    snap.files_touched = filesTouched;
+    snap.last_updated = new Date().toISOString();
+    saveSnapshot(snap);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/sanitize-on-read.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/session-reflection.js

@@ -0,0 +1,7 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/session-start-magic-docs.js

@@ -0,0 +1,7 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/session-start-reset-risk.js

@@ -0,0 +1,7 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/session-start-toolkit-reminder.js

@@ -0,0 +1,7 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    process.stdout.write("Session start toolkit reminder.\n");
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/stop-evaluator.js

@@ -0,0 +1,157 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+const REPO_ROOT = process.cwd();
+const EVALUATOR_MD = path.join(REPO_ROOT, "scripts", "hooks", "stop-evaluator.md");
+const INITIALIZER_AGENT = path.join(REPO_ROOT, "src", "scripts", "hooks", "initializer-agent.ts");
+const STATE_DIR = path.join(REPO_ROOT, ".boll", "guard");
+const METRICS_DIR = path.join(REPO_ROOT, ".boll", "metrics");
+const TTL_SECONDS = 3600;
+const WRITE_TOOLS = new Set(["Edit", "Write", "NotebookEdit"]);
+function emitMetric(event, sessionKey, data = {}) {
+    try {
+        if (!fs.existsSync(METRICS_DIR)) {
+            fs.mkdirSync(METRICS_DIR, { recursive: true });
+        }
+        const record = {
+            ts: new Date().toISOString(),
+            session_key: sessionKey,
+            event,
+            ...data,
+        };
+        fs.appendFileSync(path.join(METRICS_DIR, "stop-events.jsonl"), JSON.stringify(record) + "\n", "utf-8");
+    }
+    catch { }
+}
+function readHookPayload() {
+    try {
+        const raw = fs.readFileSync(0, "utf-8");
+        return raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function getSessionKey(payload) {
+    const sid = payload.session_id;
+    if (typeof sid === "string" && sid)
+        return sid;
+    return `ppid-${process.ppid}`;
+}
+function getStateFile(sessionKey) {
+    const safe = sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+    return path.join(STATE_DIR, `stop-${safe}.flag`);
+}
+function alreadyBlocked(sessionKey) {
+    const stateFile = getStateFile(sessionKey);
+    if (!fs.existsSync(stateFile))
+        return false;
+    try {
+        const ts = parseFloat(fs.readFileSync(stateFile, "utf-8").trim());
+        return Date.now() / 1000 - ts < TTL_SECONDS;
+    }
+    catch {
+        return false;
+    }
+}
+function markBlocked(sessionKey) {
+    if (!fs.existsSync(STATE_DIR)) {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+    }
+    fs.writeFileSync(getStateFile(sessionKey), String(Date.now() / 1000), "utf-8");
+}
+function extractEditedFiles(transcriptPath) {
+    if (!transcriptPath)
+        return null;
+    try {
+        const files = new Set();
+        const content = fs.readFileSync(transcriptPath, "utf-8");
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const rec = JSON.parse(line);
+                const msg = rec.message || {};
+                if (msg.role !== "assistant")
+                    continue;
+                const blocks = msg.content || [];
+                for (const block of blocks) {
+                    if (block.type === "tool_use" && WRITE_TOOLS.has(block.name)) {
+                        const fp = block.input?.file_path;
+                        if (fp) {
+                            try {
+                                files.add(path.relative(REPO_ROOT, fp));
+                            }
+                            catch { }
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+        return files;
+    }
+    catch {
+        return null;
+    }
+}
+function isCompletionCandidate(transcriptPath) {
+    const sessionFiles = extractEditedFiles(transcriptPath);
+    if (sessionFiles === null)
+        return [true, "transcript_unreadable_failopen"];
+    if (sessionFiles.size === 0)
+        return [false, "no_session_writes"];
+    let gitDirty = new Set();
+    try {
+        const result = execSync("git diff --name-only", { cwd: REPO_ROOT, encoding: "utf-8", timeout: 5000 });
+        if (result.trim()) {
+            gitDirty = new Set(result.trim().split("\n").filter(l => l));
+        }
+    }
+    catch { }
+    const uncommitted = new Set([...sessionFiles].filter(f => gitDirty.has(f)));
+    if (uncommitted.size > 0)
+        return [true, "uncommitted_session_changes"];
+    try {
+        const result = execSync("git diff --cached --name-only", { cwd: REPO_ROOT, encoding: "utf-8", timeout: 5000 });
+        if (result.trim())
+            return [true, "staged_changes"];
+    }
+    catch { }
+    return [false, "all_committed"];
+}
+export function main() {
+    const payload = readHookPayload();
+    const sessionKey = getSessionKey(payload);
+    if (payload.stop_hook_active === true) {
+        emitMetric("stop_pass", sessionKey, { reason: "stop_hook_active_guard" });
+        process.exit(0);
+    }
+    if (alreadyBlocked(sessionKey)) {
+        emitMetric("stop_pass", sessionKey, { reason: "already_blocked_once" });
+        process.exit(0);
+    }
+    const isCandidate = isCompletionCandidate(payload.transcript_path || "");
+    if (!isCandidate[0]) {
+        emitMetric("stop_pass", sessionKey, { reason: isCandidate[1] });
+        process.exit(0);
+    }
+    if (!fs.existsSync(EVALUATOR_MD)) {
+        emitMetric("stop_skip", sessionKey, { reason: "evaluator_md_missing" });
+        process.exit(0);
+    }
+    try {
+        const checklist = fs.readFileSync(EVALUATOR_MD, "utf-8");
+        process.stderr.write(checklist + "\n");
+        markBlocked(sessionKey);
+        emitMetric("stop_block", sessionKey, { reason: `completion_candidate_${isCandidate[1]}` });
+        process.exit(2);
+    }
+    catch {
+        emitMetric("stop_skip", sessionKey, { reason: "evaluator_md_read_error" });
+        process.exit(0);
+    }
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/tool-call-counter.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/hooks/trace-analyzer.js

@@ -0,0 +1,10 @@
+export function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--analyze")) {
+        process.stdout.write("Trace analysis complete.\n");
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/install/install-trust-token.js

@@ -0,0 +1,7 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/install/multi_project_registry.js

@@ -0,0 +1,9 @@
+import * as path from "path";
+const REPO_ROOT = process.cwd();
+const REGISTRY_FILE = path.join(REPO_ROOT, ".boll", "install-log.jsonl");
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/install/phase2_auto.js

@@ -0,0 +1,21 @@
+import * as path from "path";
+const REPO_ROOT = process.cwd();
+const TRUST_TOKEN_FILE = path.join(REPO_ROOT, ".boll", "install-trust-token.json");
+export function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--install")) {
+        const targetProject = args[args.indexOf("--install") + 1];
+        if (!targetProject) {
+            console.error("Usage: phase2_auto.ts --install <project-path>");
+            process.exit(1);
+        }
+        console.log(`Installing bollharness to ${targetProject}`);
+        process.exit(0);
+    }
+    console.log("bollharness installer");
+    console.log("Usage: phase2_auto.ts --install <project-path> [--tier drop-in|adapt|mine]");
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/install/pre_commit_installer.js

@@ -0,0 +1,6 @@
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/install/tier_selector.js

@@ -0,0 +1,7 @@
+export function selectTier(tier) {
+    const validTiers = ["drop-in", "adapt", "mine"];
+    if (!validTiers.includes(tier)) {
+        return "drop-in";
+    }
+    return tier;
+}