@bolloon/bolloon-agent 0.2.1 → 0.2.3

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"],
+    ["Bolloon.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;
+}

package/dist/bollharness/src/scripts/install/transcript_miner.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/lib/claim_patterns.js

@@ -0,0 +1,10 @@
+export const CLAIM_PATTERNS = [
+    /test[s]?\s+(pass|run|complete[ds]?)/gi,
+    /all\s+test[s]?\s+(pass|run)/gi,
+    /fix(?:ed|es)?\s+the?\s+(bug|issue|problem)/gi,
+    /complete[ds]?/gi,
+    /done/gi,
+];
+export function hasUnverifiedClaim(text) {
+    return CLAIM_PATTERNS.some(pattern => pattern.test(text));
+}

package/dist/bollharness/src/scripts/lib/sanitize_patterns.js

@@ -0,0 +1,12 @@
+export const SANITIZE_PATTERNS = [
+    { pattern: /api[_-]?key["\s:=]+["'][a-zA-Z0-9]{20,}["']/gi, replacement: "***REDACTED***" },
+    { pattern: /password["\s:=]+["'][^"']{8,}["']/gi, replacement: "***REDACTED***" },
+    { pattern: /secret["\s:=]+["'][a-zA-Z0-9]{16,}["']/gi, replacement: "***REDACTED***" },
+];
+export function sanitize(text) {
+    let result = text;
+    for (const { pattern, replacement } of SANITIZE_PATTERNS) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}

package/dist/bollharness/src/scripts/sanitize.js

@@ -0,0 +1,6 @@
+export function sanitize(text) {
+    return text
+        .replace(/api[_-]?key["\s:=]+["'][a-zA-Z0-9]{20,}["']/gi, "***REDACTED***")
+        .replace(/password["\s:=]+["'][^"']{8,}["']/gi, "***REDACTED***")
+        .replace(/secret["\s:=]+["'][a-zA-Z0-9]{16,}["']/gi, "***REDACTED***");
+}

package/dist/constraint-runtime/src/tools/PolymarketSDK/cancelOrder.js

@@ -0,0 +1,6 @@
+export async function cancelOrder(params) {
+    return {
+        success: false,
+        message: 'Polymarket order cancellation requires CLOB client with authentication. Use the Polymarket web interface to cancel orders.',
+    };
+}

package/dist/constraint-runtime/src/tools/PolymarketSDK/createOrder.js

@@ -0,0 +1,6 @@
+export async function createOrder(params) {
+    return {
+        success: false,
+        message: 'Polymarket order creation requires CLOB client with authentication. Use the Polymarket web interface to create orders.',
+    };
+}

package/dist/constraint-runtime/src/tools/PolymarketSDK/getMarket.js

@@ -0,0 +1,5 @@
+export async function getMarket(id) {
+    const { listMarkets } = await import('polymarket-sdk').catch(() => ({ listMarkets: async () => [] }));
+    const markets = await listMarkets({ id });
+    return markets[0] ?? null;
+}

package/dist/constraint-runtime/src/tools/PolymarketSDK/getOrders.js

@@ -0,0 +1,6 @@
+export async function getOrders(params = {}) {
+    return {
+        orders: [],
+        message: 'Polymarket order retrieval requires CLOB client with authentication. Use the Polymarket web interface to view orders.',
+    };
+}

package/dist/constraint-runtime/src/tools/PolymarketSDK/listMarkets.js

@@ -0,0 +1,4 @@
+export async function listMarkets(params = {}) {
+    const { listMarkets: marketsFn } = await import('polymarket-sdk').catch(() => ({ listMarkets: async () => [] }));
+    return marketsFn(params);
+}

package/dist/constraint-runtime/src/tools/SafeSDK/deploySafe.js

@@ -0,0 +1,6 @@
+export async function deploySafe(params) {
+    return {
+        success: false,
+        message: 'Safe deployment requires protocol kit with deployer wallet configured.',
+    };
+}

package/dist/constraint-runtime/src/tools/WalletTools/autoPay.js

@@ -0,0 +1,29 @@
+const autoPayStore = new Map();
+export async function setAutoPay(params) {
+    const { Wallet } = await import('ethers');
+    const wallet = new Wallet(params.walletPrivateKey);
+    const config = {
+        enabled: true,
+        walletPrivateKey: params.walletPrivateKey,
+        rpcUrl: params.rpcUrl ?? 'https://eth.llamarpc.com',
+        maxGasPrice: params.maxGasPrice,
+        whitelist: params.whitelist,
+    };
+    autoPayStore.set(params.agentId, config);
+    return {
+        agentId: params.agentId,
+        enabled: true,
+        walletAddress: wallet.address,
+        rpcUrl: config.rpcUrl,
+    };
+}
+export async function getAutoPayConfig(agentId) {
+    return autoPayStore.get(agentId) ?? null;
+}
+export async function disableAutoPay(agentId) {
+    const config = autoPayStore.get(agentId);
+    if (config) {
+        config.enabled = false;
+    }
+    return { agentId, enabled: false };
+}

package/dist/constraint-runtime/src/tools/WalletTools/createWallet.js

@@ -0,0 +1,10 @@
+import { Wallet } from 'ethers';
+export async function createWallet() {
+    const wallet = Wallet.createRandom();
+    return {
+        address: wallet.address,
+        privateKey: wallet.privateKey,
+        mnemonic: wallet.mnemonic?.phrase ?? '',
+        createdAt: new Date().toISOString(),
+    };
+}

package/dist/constraint-runtime/src/tools/WalletTools/getBalance.js

@@ -0,0 +1,13 @@
+import { JsonRpcProvider } from 'ethers';
+export async function getBalance(params) {
+    const rpcUrl = params.rpcUrl ?? 'https://eth.llamarpc.com';
+    const provider = new JsonRpcProvider(rpcUrl);
+    const balance = await provider.getBalance(params.address);
+    const balanceEth = Number(balance) / 1e18;
+    return {
+        address: params.address,
+        balance: balance.toString(),
+        balanceEth: balanceEth.toFixed(6),
+        symbol: 'ETH',
+    };
+}