@bolloon/bolloon-agent 0.2.2 → 0.2.3

package/dist/bollharness/src/scripts/checks/check_doc_freshness.js

@@ -0,0 +1,135 @@
+import * as fs from "fs";
+import * as path from "path";
+function countRouteDecorators(repoRoot) {
+    const routesDir = path.join(repoRoot, "backend", "product", "routes");
+    if (!fs.existsSync(routesDir))
+        return 0;
+    let count = 0;
+    try {
+        const files = fs.readdirSync(routesDir).filter(f => f.endsWith(".py"));
+        for (const file of files) {
+            const content = fs.readFileSync(path.join(routesDir, file), "utf-8");
+            const matches = content.match(/@router\.(get|post|put|patch|delete|websocket)\(/g);
+            if (matches)
+                count += matches.length;
+        }
+    }
+    catch { }
+    return count;
+}
+function countScenes(repoRoot) {
+    const scenesDir = path.join(repoRoot, "scenes");
+    if (!fs.existsSync(scenesDir))
+        return 0;
+    try {
+        return fs.readdirSync(scenesDir).filter(f => {
+            const fullPath = path.join(scenesDir, f);
+            return fs.statSync(fullPath).isDirectory() && !f.startsWith(".");
+        }).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function countADRs(repoRoot) {
+    const decisions = path.join(repoRoot, "docs", "decisions");
+    if (!fs.existsSync(decisions))
+        return 0;
+    try {
+        return fs.readdirSync(decisions).filter(f => f.startsWith("ADR-") && f.endsWith(".md")).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function countPlans(repoRoot) {
+    const decisions = path.join(repoRoot, "docs", "decisions");
+    if (!fs.existsSync(decisions))
+        return 0;
+    try {
+        return fs.readdirSync(decisions).filter(f => f.startsWith("PLAN-") && f.endsWith(".md")).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function extractRoadmapNumbers(repoRoot) {
+    const roadmap = path.join(repoRoot, "docs", "ROADMAP.md");
+    if (!fs.existsSync(roadmap))
+        return {};
+    const content = fs.readFileSync(roadmap, "utf-8");
+    const numbers = {};
+    const regex = /\|\s*(\S[^|]+?)\s*\|\s*(\S[^|]+?)\s*\|/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const key = match[1].trim();
+        const val = match[2].trim();
+        if (key !== "指标" && key !== "---") {
+            numbers[key] = val;
+        }
+    }
+    return numbers;
+}
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    const actualRoutes = countRouteDecorators(repoRoot);
+    const routesDoc = path.join(repoRoot, ".boll", "rules", "backend-routes.md");
+    const claudeMd = path.join(repoRoot, "Bolloon.md");
+    if (fs.existsSync(routesDoc)) {
+        const routesContent = fs.readFileSync(routesDoc, "utf-8");
+        const routeClaims = routesContent.match(/-\s+`(?:GET|POST|PUT|PATCH|DELETE|WS)\s+/g) || [];
+        const docRoutes = routeClaims.length;
+        if (actualRoutes - docRoutes > 5) {
+            findings.push({
+                severity: "P1",
+                message: `.boll/rules/backend-routes.md documents ${docRoutes} routes but code has ${actualRoutes} decorators (gap: ${actualRoutes - docRoutes})`,
+                file: ".boll/rules/backend-routes.md",
+                blocking: false,
+                category: "doc_integrity",
+                problem_class: "unknown",
+                required_skills: [],
+                required_reads: [],
+            });
+        }
+    }
+    const actualADRs = countADRs(repoRoot);
+    const actualPlans = countPlans(repoRoot);
+    const roadmapNums = extractRoadmapNumbers(repoRoot);
+    if ("ADR" in roadmapNums) {
+        const match = roadmapNums["ADR"].match(/\d+/);
+        if (match) {
+            const claimed = parseInt(match[0], 10);
+            if (actualADRs - claimed > 2) {
+                findings.push({
+                    severity: "P2",
+                    message: `ROADMAP claims ${claimed} ADRs but ${actualADRs} exist`,
+                    file: "docs/ROADMAP.md",
+                    blocking: false,
+                    category: "doc_integrity",
+                    problem_class: "unknown",
+                    required_skills: [],
+                    required_reads: [],
+                });
+            }
+        }
+    }
+    if ("PLAN" in roadmapNums) {
+        const match = roadmapNums["PLAN"].match(/\d+/);
+        if (match) {
+            const claimed = parseInt(match[0], 10);
+            if (actualPlans - claimed > 3) {
+                findings.push({
+                    severity: "P2",
+                    message: `ROADMAP claims ${claimed} PLANs but ${actualPlans} exist`,
+                    file: "docs/ROADMAP.md",
+                    blocking: false,
+                    category: "doc_integrity",
+                    problem_class: "unknown",
+                    required_skills: [],
+                    required_reads: [],
+                });
+            }
+        }
+    }
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_doc_links.js

@@ -0,0 +1,31 @@
+import * as fs from "fs";
+import * as path from "path";
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    const docFiles = ["Bolloon.md", "docs/ROADMAP.md", "README.md"];
+    const maxAgeDays = 7;
+    for (const docFile of docFiles) {
+        const fullPath = path.join(repoRoot, docFile);
+        if (!fs.existsSync(fullPath))
+            continue;
+        try {
+            const stats = fs.statSync(fullPath);
+            const ageMs = Date.now() - stats.mtimeMs;
+            const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+            if (ageDays > maxAgeDays) {
+                findings.push({
+                    severity: "P2",
+                    message: `${docFile} has not been updated in ${ageDays} days (threshold: ${maxAgeDays})`,
+                    file: docFile,
+                    blocking: false,
+                    category: "doc_freshness",
+                    problem_class: "unknown",
+                    required_skills: [],
+                    required_reads: [],
+                });
+            }
+        }
+        catch { }
+    }
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_file_existence_claims.js

@@ -0,0 +1,6 @@
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    if (mode !== "full" && mode !== "staged")
+        return findings;
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_fragment_integrity.js

@@ -0,0 +1,34 @@
+import * as fs from "fs";
+import * as path from "path";
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    const fragmentDir = path.join(repoRoot, "scripts", "context-fragments");
+    const routerFile = path.join(repoRoot, "src", "scripts", "context_router.ts");
+    if (!fs.existsSync(routerFile)) {
+        findings.push({
+            severity: "P1",
+            message: "context_router.ts not found",
+            file: "src/scripts/context_router.ts",
+            blocking: false,
+            category: "governance_bootstrap",
+            problem_class: "unknown",
+            required_skills: [],
+            required_reads: [],
+        });
+        return findings;
+    }
+    if (!fs.existsSync(fragmentDir)) {
+        findings.push({
+            severity: "P2",
+            message: "context-fragments directory not found",
+            file: "scripts/context-fragments/",
+            blocking: false,
+            category: "governance_bootstrap",
+            problem_class: "unknown",
+            required_skills: [],
+            required_reads: [],
+        });
+        return findings;
+    }
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_hook_installed.js

@@ -0,0 +1,63 @@
+import * as fs from "fs";
+import * as path from "path";
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    const hookFiles = [
+        "src/scripts/hooks/loop-detection.ts",
+        "src/scripts/hooks/risk-tracker.ts",
+        "src/scripts/hooks/stop-evaluator.ts",
+        "src/scripts/hooks/guard-feedback.ts",
+        "src/scripts/hooks/deploy-guard.ts",
+    ];
+    const settingsFile = path.join(repoRoot, ".boll", "settings.json");
+    if (!fs.existsSync(settingsFile)) {
+        findings.push({
+            severity: "P1",
+            message: ".boll/settings.json does not exist",
+            file: ".boll/settings.json",
+            blocking: false,
+            category: "general",
+            problem_class: "unknown",
+            required_skills: [],
+            required_reads: [],
+        });
+        return findings;
+    }
+    try {
+        const settings = JSON.parse(fs.readFileSync(settingsFile, "utf-8"));
+        const registeredHooks = settings.hooks || {};
+        for (const [stage, hooks] of Object.entries(registeredHooks)) {
+            const hookList = hooks;
+            for (const hookGroup of hookList) {
+                for (const hook of hookGroup.hooks || []) {
+                    const cmd = hook.command || "";
+                    if (cmd.includes("python3") && cmd.includes(".py")) {
+                        findings.push({
+                            severity: "P1",
+                            message: `Hook in ${stage} still references Python script: ${cmd}`,
+                            file: ".boll/settings.json",
+                            blocking: false,
+                            category: "governance_bootstrap",
+                            problem_class: "unknown",
+                            required_skills: [],
+                            required_reads: [],
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch (exc) {
+        findings.push({
+            severity: "P1",
+            message: `Failed to parse settings.json: ${exc}`,
+            file: ".boll/settings.json",
+            blocking: false,
+            category: "governance_bootstrap",
+            problem_class: "unknown",
+            required_skills: [],
+            required_reads: [],
+        });
+    }
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_issue_closure.js

@@ -0,0 +1,41 @@
+import * as fs from "fs";
+import * as path from "path";
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    const docsIssuesDir = path.join(repoRoot, "docs", "issues");
+    if (!fs.existsSync(docsIssuesDir)) {
+        return findings;
+    }
+    const issueFiles = fs.readdirSync(docsIssuesDir).filter(f => f.endsWith(".md"));
+    for (const issueFile of issueFiles) {
+        const issuePath = path.join(docsIssuesDir, issueFile);
+        const content = fs.readFileSync(issuePath, "utf-8");
+        const hasStatus = /^(status|State):\s*/im.test(content);
+        const hasResolution = /^(resolution|Closed):\s*/im.test(content);
+        if (!hasStatus) {
+            findings.push({
+                severity: "P2",
+                message: `Issue ${issueFile} missing status field`,
+                file: `docs/issues/${issueFile}`,
+                blocking: false,
+                category: "doc_integrity",
+                problem_class: "unknown",
+                required_skills: [],
+                required_reads: [],
+            });
+        }
+        if (!hasResolution) {
+            findings.push({
+                severity: "P2",
+                message: `Issue ${issueFile} missing resolution/closed field`,
+                file: `docs/issues/${issueFile}`,
+                blocking: false,
+                category: "doc_integrity",
+                problem_class: "unknown",
+                required_skills: [],
+                required_reads: [],
+            });
+        }
+    }
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_mcp_parity.js

@@ -0,0 +1,6 @@
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    if (mode !== "full" && mode !== "ci")
+        return findings;
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_security.js

@@ -0,0 +1,48 @@
+import * as fs from "fs";
+import * as path from "path";
+const SENSITIVE_PATTERNS = [
+    { pattern: /api[_-]?key["\s:=]+["'][a-zA-Z0-9]{20,}["']/gi, severity: "P0" },
+    { pattern: /password["\s:=]+["'][^"']{8,}["']/gi, severity: "P0" },
+    { pattern: /secret["\s:=]+["'][a-zA-Z0-9]{16,}["']/gi, severity: "P0" },
+    { pattern: /token["\s:=]+["'][a-zA-Z0-9]{20,}["']/gi, severity: "P1" },
+    { pattern: /bearer\s+[a-zA-Z0-9]{20,}/gi, severity: "P1" },
+];
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    if (mode !== "full" && mode !== "ci")
+        return findings;
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".json", ".yaml", ".yml"];
+    function scanDir(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+                    scanDir(fullPath);
+                }
+            }
+            else if (extensions.includes(path.extname(entry.name))) {
+                const content = fs.readFileSync(fullPath, "utf-8");
+                for (const { pattern, severity } of SENSITIVE_PATTERNS) {
+                    const matches = content.match(pattern);
+                    if (matches) {
+                        findings.push({
+                            severity,
+                            message: `Potential secret detected: ${matches[0].slice(0, 30)}...`,
+                            file: path.relative(repoRoot, fullPath),
+                            blocking: severity === "P0",
+                            category: "security",
+                            problem_class: "secret_exposure",
+                            required_skills: [],
+                            required_reads: [],
+                        });
+                    }
+                }
+            }
+        }
+    }
+    scanDir(repoRoot);
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_skill_parity.js

@@ -0,0 +1,6 @@
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    if (mode !== "full" && mode !== "ci")
+        return findings;
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/check_versions.js

@@ -0,0 +1,6 @@
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    if (mode !== "full" && mode !== "ci")
+        return findings;
+    return findings;
+}

package/dist/bollharness/src/scripts/checks/finding.js

@@ -0,0 +1,13 @@
+export function createFinding(params) {
+    return {
+        severity: params.severity,
+        message: params.message,
+        file: params.file,
+        line: params.line,
+        blocking: params.blocking ?? false,
+        category: params.category ?? "general",
+        problem_class: params.problem_class ?? "unknown",
+        required_skills: params.required_skills ?? [],
+        required_reads: params.required_reads ?? [],
+    };
+}

package/dist/bollharness/src/scripts/checks/next_decision_number.js

@@ -0,0 +1,20 @@
+import { execSync } from "child_process";
+const REPO_ROOT = process.cwd();
+export function main() {
+    const args = process.argv.slice(2);
+    if (args[0] === "next") {
+        try {
+            const result = execSync("git log --oneline -1", { cwd: REPO_ROOT, encoding: "utf-8" });
+            const match = result.match(/ADR-(\d+)/);
+            if (match) {
+                const nextNum = parseInt(match[1], 10) + 1;
+                console.log(`ADR-${nextNum}`);
+            }
+        }
+        catch { }
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/checks/regenerate_magic_docs.js

@@ -0,0 +1,6 @@
+export function run(repoRoot, mode = "full") {
+    const findings = [];
+    if (mode !== "full" && mode !== "ci")
+        return findings;
+    return findings;
+}

package/dist/bollharness/src/scripts/ci/detect_rebaseline_triggers.js

@@ -0,0 +1,8 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    console.log("Detecting rebase triggers...");
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/ci/scan_subprocess_cfg.js

@@ -0,0 +1,8 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    console.log("Scanning subprocess configurations...");
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/ci/scan_verify_artifacts.js

@@ -0,0 +1,8 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    console.log("Scanning for artifact verification...");
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/ci/scan_yaml_schema.js

@@ -0,0 +1,8 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    console.log("Scanning YAML schemas...");
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

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

@@ -0,0 +1,67 @@
+import * as fs from "fs";
+import * as path from "path";
+export const FRAGMENTS_DIR = path.join(__dirname, "..", "context-fragments");
+export const CONTEXT_MAP = {
+    "bridge_agent/": ["bridge-constitution"],
+    "backend/product/bridge/": ["bridge-constitution"],
+    "mcp-server/": ["mcp-parity"],
+    "mcp-server-node/": ["mcp-parity"],
+    "backend/product/routes/protocol.py": ["protocol-consumers", "contract-consumers"],
+    "backend/product/protocol/": ["protocol-consumers"],
+    "backend/product/routes/": ["contract-consumers"],
+    "backend/product/db/crud_events.py": ["run-events-consumers"],
+    "backend/product/auth/": ["auth-consumers"],
+    "backend/product/db/": ["db-shared-structures"],
+    "backend/product/catalyst/": ["catalyst-distributed"],
+    "docs/issues/": ["fixed-three-layers", "closure-checklist"],
+    "scenes/": ["scene-fidelity", "two-language"],
+    "website/app/[scene]/": ["scene-fidelity", "two-language"],
+    "website/components/scene/": ["scene-fidelity", "two-language"],
+    "Bolloon.md": ["truth-source-hierarchy"],
+    "MEMORY.md": ["truth-source-hierarchy"],
+    "docs/INDEX.md": ["truth-source-hierarchy"],
+    "mcp-server/pyproject.toml": ["version-sources"],
+    "mcp-server-node/package.json": ["version-sources"],
+    "website/": ["two-language"],
+    "docs/decisions/": ["artifact-linkage"],
+    "backend/product/": ["issue-first"],
+    "backend/server.py": ["issue-first"],
+    "mcp-server/boll_mcp/": ["issue-first"],
+    "mcp-server-node/src/": ["issue-first"],
+    "website/app/": ["issue-first"],
+};
+export const FALLBACK_FRAGMENTS = ["general-dev-principles"];
+export function match(filePath) {
+    if (!filePath)
+        return [];
+    if (path.isAbsolute(filePath))
+        return [];
+    const normalized = path.normalize(filePath).replace(/\\/g, "/");
+    if (normalized.startsWith("../") || normalized === ".." || normalized.includes("/../")) {
+        return [];
+    }
+    const matched = [];
+    const sortedPatterns = Object.keys(CONTEXT_MAP).sort((a, b) => b.length - a.length);
+    for (const pattern of sortedPatterns) {
+        if (normalized.startsWith(pattern) || normalized.endsWith(pattern)) {
+            matched.push(...CONTEXT_MAP[pattern]);
+        }
+    }
+    return [...new Set(matched)];
+}
+export function loadFragment(name) {
+    if (!name)
+        return "";
+    const candidate = path.join(FRAGMENTS_DIR, `${name}.md`);
+    try {
+        const resolved = path.resolve(candidate);
+        const fragmentsDirResolved = path.resolve(FRAGMENTS_DIR);
+        if (!resolved.startsWith(fragmentsDirResolved))
+            return "";
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+            return fs.readFileSync(resolved, "utf-8").trim();
+        }
+    }
+    catch { }
+    return "";
+}