codebot-ai 1.6.0 → 1.8.0

package/dist/policy.js

@@ -0,0 +1,444 @@
+"use strict";
+/**
+ * Policy Engine for CodeBot v1.7.0
+ *
+ * Loads, validates, and enforces declarative security policies.
+ * Policy files: .codebot/policy.json (project) + ~/.codebot/policy.json (global)
+ * Project policy overrides global policy where specified.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyEnforcer = exports.DEFAULT_POLICY = void 0;
+exports.loadPolicy = loadPolicy;
+exports.generateDefaultPolicyFile = generateDefaultPolicyFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const capabilities_1 = require("./capabilities");
+// ── Default Policy ──
+exports.DEFAULT_POLICY = {
+    version: '1.0',
+    execution: {
+        sandbox: 'auto',
+        network: false, // safe default: no network in sandbox
+        timeout_seconds: 120,
+        max_memory_mb: 512,
+    },
+    filesystem: {
+        writable_paths: [], // empty = all project paths allowed
+        read_only_paths: [],
+        denied_paths: ['.env', '.env.local', '.env.production'],
+        allow_outside_project: false,
+    },
+    tools: {
+        enabled: [], // empty = all tools enabled
+        disabled: [],
+        permissions: {},
+    },
+    secrets: {
+        block_on_detect: true, // safe default: block writes containing secrets
+        scan_on_write: true,
+        allowed_patterns: [],
+    },
+    git: {
+        always_branch: true, // safe default: auto-branch on first write
+        branch_prefix: 'codebot/',
+        require_tests_before_commit: false,
+        never_push_main: true,
+    },
+    mcp: {
+        allowed_servers: [], // empty = all allowed
+        blocked_servers: [],
+    },
+    limits: {
+        max_iterations: 50,
+        max_file_size_kb: 500,
+        max_files_per_operation: 20,
+        cost_limit_usd: 0, // 0 = no limit
+    },
+};
+// ── Policy Loader ──
+/**
+ * Load and merge policies from project + global locations.
+ * Project policy overrides global where specified.
+ */
+function loadPolicy(projectRoot) {
+    const root = projectRoot || process.cwd();
+    // Load global policy
+    const globalPath = path.join(os.homedir(), '.codebot', 'policy.json');
+    const globalPolicy = loadPolicyFile(globalPath);
+    // Load project policy
+    const projectPath = path.join(root, '.codebot', 'policy.json');
+    const projectPolicy = loadPolicyFile(projectPath);
+    // Merge: defaults ← global ← project (project wins)
+    return mergePolicies(exports.DEFAULT_POLICY, globalPolicy, projectPolicy);
+}
+function loadPolicyFile(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (!validatePolicy(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Basic validation — ensures the policy file has a recognizable shape.
+ * Does NOT throw — returns false for invalid policies (fail-open with defaults).
+ */
+function validatePolicy(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const p = obj;
+    // Version check
+    if (p.version !== undefined && typeof p.version !== 'string')
+        return false;
+    // Type check each section
+    if (p.execution !== undefined && typeof p.execution !== 'object')
+        return false;
+    if (p.filesystem !== undefined && typeof p.filesystem !== 'object')
+        return false;
+    if (p.tools !== undefined && typeof p.tools !== 'object')
+        return false;
+    if (p.secrets !== undefined && typeof p.secrets !== 'object')
+        return false;
+    if (p.git !== undefined && typeof p.git !== 'object')
+        return false;
+    if (p.mcp !== undefined && typeof p.mcp !== 'object')
+        return false;
+    if (p.limits !== undefined && typeof p.limits !== 'object')
+        return false;
+    return true;
+}
+/**
+ * Deep merge policies. Later arguments override earlier ones.
+ * Only defined keys in higher-priority policies override lower ones.
+ */
+function mergePolicies(...policies) {
+    const result = {};
+    for (const policy of policies) {
+        if (!policy)
+            continue;
+        for (const [key, value] of Object.entries(policy)) {
+            if (value === undefined || value === null)
+                continue;
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                // Deep merge objects
+                result[key] = { ...(result[key] || {}), ...value };
+            }
+            else {
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+}
+// ── Policy Enforcer ──
+class PolicyEnforcer {
+    policy;
+    projectRoot;
+    constructor(policy, projectRoot) {
+        this.policy = policy || loadPolicy(projectRoot);
+        this.projectRoot = projectRoot || process.cwd();
+    }
+    getPolicy() {
+        return this.policy;
+    }
+    // ── Tool Access ──
+    /** Check if a tool is enabled by policy. Returns { allowed, reason }. */
+    isToolAllowed(toolName) {
+        const tools = this.policy.tools;
+        if (!tools)
+            return { allowed: true };
+        // If explicit disabled list contains it, block
+        if (tools.disabled && tools.disabled.length > 0) {
+            if (tools.disabled.includes(toolName)) {
+                return { allowed: false, reason: `Tool "${toolName}" is disabled by policy` };
+            }
+        }
+        // If explicit enabled list exists and is non-empty, only those tools are allowed
+        if (tools.enabled && tools.enabled.length > 0) {
+            if (!tools.enabled.includes(toolName)) {
+                return { allowed: false, reason: `Tool "${toolName}" is not in the enabled tools list` };
+            }
+        }
+        return { allowed: true };
+    }
+    /** Get the permission level for a tool (policy override or null for default). */
+    getToolPermission(toolName) {
+        return this.policy.tools?.permissions?.[toolName] || null;
+    }
+    // ── Filesystem Access ──
+    /** Check if a path is writable according to policy. */
+    isPathWritable(filePath) {
+        const fs_policy = this.policy.filesystem;
+        if (!fs_policy)
+            return { allowed: true };
+        const resolved = path.resolve(filePath);
+        const relative = path.relative(this.projectRoot, resolved);
+        // Check denied paths first (highest priority)
+        if (fs_policy.denied_paths && fs_policy.denied_paths.length > 0) {
+            for (const denied of fs_policy.denied_paths) {
+                const deniedResolved = path.resolve(this.projectRoot, denied);
+                if (resolved === deniedResolved || resolved.startsWith(deniedResolved + path.sep)) {
+                    return { allowed: false, reason: `Path "${relative}" is denied by policy` };
+                }
+                // Also check as a glob-like prefix
+                if (this.matchesPattern(relative, denied)) {
+                    return { allowed: false, reason: `Path "${relative}" matches denied pattern "${denied}"` };
+                }
+            }
+        }
+        // Check read-only paths
+        if (fs_policy.read_only_paths && fs_policy.read_only_paths.length > 0) {
+            for (const ro of fs_policy.read_only_paths) {
+                const roResolved = path.resolve(this.projectRoot, ro);
+                if (resolved === roResolved || resolved.startsWith(roResolved + path.sep)) {
+                    return { allowed: false, reason: `Path "${relative}" is read-only by policy` };
+                }
+            }
+        }
+        // Check writable paths (if specified, only these are writable)
+        if (fs_policy.writable_paths && fs_policy.writable_paths.length > 0) {
+            let matched = false;
+            for (const wp of fs_policy.writable_paths) {
+                const wpResolved = path.resolve(this.projectRoot, wp);
+                if (resolved === wpResolved || resolved.startsWith(wpResolved + path.sep)) {
+                    matched = true;
+                    break;
+                }
+                if (this.matchesPattern(relative, wp)) {
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                return { allowed: false, reason: `Path "${relative}" is not in the writable paths list` };
+            }
+        }
+        return { allowed: true };
+    }
+    // ── Execution Policy ──
+    /** Get sandbox mode. */
+    getSandboxMode() {
+        return this.policy.execution?.sandbox || 'auto';
+    }
+    /** Check if network is allowed for executed commands. */
+    isNetworkAllowed() {
+        return this.policy.execution?.network !== false;
+    }
+    /** Get execution timeout in milliseconds. */
+    getTimeoutMs() {
+        const seconds = this.policy.execution?.timeout_seconds || 120;
+        return seconds * 1000;
+    }
+    /** Get max memory in MB for sandbox. */
+    getMaxMemoryMb() {
+        return this.policy.execution?.max_memory_mb || 512;
+    }
+    // ── Git Policy ──
+    /** Check if agent should always work on a branch. */
+    shouldAlwaysBranch() {
+        return this.policy.git?.always_branch === true;
+    }
+    /** Get branch prefix for auto-created branches. */
+    getBranchPrefix() {
+        return this.policy.git?.branch_prefix || 'codebot/';
+    }
+    /** Check if pushing to main/master is blocked. */
+    isMainPushBlocked() {
+        return this.policy.git?.never_push_main !== false; // default true
+    }
+    // ── Secrets Policy ──
+    /** Should secrets block writes (vs just warn)? */
+    shouldBlockSecrets() {
+        return this.policy.secrets?.block_on_detect === true;
+    }
+    /** Should scan for secrets on write? */
+    shouldScanSecrets() {
+        return this.policy.secrets?.scan_on_write !== false; // default true
+    }
+    // ── MCP Policy ──
+    /** Check if an MCP server is allowed. */
+    isMcpServerAllowed(serverName) {
+        const mcp = this.policy.mcp;
+        if (!mcp)
+            return { allowed: true };
+        // Blocked list takes priority
+        if (mcp.blocked_servers && mcp.blocked_servers.length > 0) {
+            if (mcp.blocked_servers.includes(serverName)) {
+                return { allowed: false, reason: `MCP server "${serverName}" is blocked by policy` };
+            }
+        }
+        // If allowed list is non-empty, only those servers are allowed
+        if (mcp.allowed_servers && mcp.allowed_servers.length > 0) {
+            if (!mcp.allowed_servers.includes(serverName)) {
+                return { allowed: false, reason: `MCP server "${serverName}" is not in the allowed list` };
+            }
+        }
+        return { allowed: true };
+    }
+    // ── Limits ──
+    /** Get max iterations for the agent loop. */
+    getMaxIterations() {
+        return this.policy.limits?.max_iterations || 50;
+    }
+    /** Get max file size in bytes for write operations. */
+    getMaxFileSizeBytes() {
+        return (this.policy.limits?.max_file_size_kb || 500) * 1024;
+    }
+    /** Get cost limit in USD (0 = no limit). */
+    getCostLimitUsd() {
+        return this.policy.limits?.cost_limit_usd || 0;
+    }
+    // ── Capabilities (v1.8.0) ──
+    /** Get capability restrictions for a tool. undefined = unrestricted. */
+    getToolCapabilities(toolName) {
+        return this.policy.tools?.capabilities?.[toolName];
+    }
+    /** Check a specific capability for a tool. Returns { allowed, reason }. */
+    checkCapability(toolName, capabilityType, value) {
+        const caps = this.policy.tools?.capabilities;
+        if (!caps)
+            return { allowed: true };
+        const checker = new capabilities_1.CapabilityChecker(caps, this.projectRoot);
+        return checker.checkCapability(toolName, capabilityType, value);
+    }
+    // ── Helpers ──
+    /**
+     * Simple glob-like pattern matching:
+     * - `*` matches any single path component
+     * - `**` matches any number of path components
+     * - `.env` matches exact filename
+     */
+    matchesPattern(relativePath, pattern) {
+        // Exact match
+        if (relativePath === pattern)
+            return true;
+        // Simple prefix match (handles ./src, ./tests)
+        const cleanPattern = pattern.replace(/^\.\//, '');
+        const cleanPath = relativePath.replace(/^\.\//, '');
+        if (cleanPath === cleanPattern)
+            return true;
+        if (cleanPath.startsWith(cleanPattern + '/'))
+            return true;
+        if (cleanPath.startsWith(cleanPattern + path.sep))
+            return true;
+        // Basename match (handles .env, .env.local)
+        if (!pattern.includes('/') && !pattern.includes(path.sep)) {
+            if (path.basename(relativePath) === pattern)
+                return true;
+        }
+        // Glob-like: ** matches any depth
+        if (pattern.includes('**')) {
+            const regex = new RegExp('^' +
+                pattern
+                    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+                    .replace(/\*\*/g, '.*')
+                    .replace(/\*/g, '[^/]*') +
+                '$');
+            return regex.test(cleanPath);
+        }
+        return false;
+    }
+}
+exports.PolicyEnforcer = PolicyEnforcer;
+/**
+ * Generate a default policy file content for `codebot --init-policy`.
+ */
+function generateDefaultPolicyFile() {
+    return JSON.stringify({
+        version: '1.0',
+        execution: {
+            sandbox: 'auto',
+            network: false,
+            timeout_seconds: 120,
+            max_memory_mb: 512,
+        },
+        filesystem: {
+            writable_paths: [],
+            read_only_paths: [],
+            denied_paths: ['.env', '.env.local', '.env.production'],
+            allow_outside_project: false,
+        },
+        tools: {
+            enabled: [],
+            disabled: [],
+            permissions: {
+                execute: 'always-ask',
+                write_file: 'prompt',
+                edit_file: 'prompt',
+            },
+            capabilities: {
+                execute: {
+                    shell_commands: [
+                        'npm', 'npx', 'node', 'git', 'tsc', 'eslint', 'prettier',
+                        'jest', 'vitest', 'pytest', 'make', 'cargo', 'go', 'python',
+                        'python3', 'ruby', 'php', 'java', 'javac', 'mvn', 'gradle',
+                        'docker', 'ls', 'cat', 'head', 'tail', 'wc', 'sort', 'uniq',
+                        'find', 'which', 'echo', 'pwd', 'env', 'date',
+                    ],
+                    max_output_kb: 500,
+                },
+            },
+        },
+        secrets: {
+            block_on_detect: true,
+            scan_on_write: true,
+        },
+        git: {
+            always_branch: true,
+            branch_prefix: 'codebot/',
+            require_tests_before_commit: false,
+            never_push_main: true,
+        },
+        mcp: {
+            allowed_servers: [],
+            blocked_servers: [],
+        },
+        limits: {
+            max_iterations: 50,
+            max_file_size_kb: 500,
+            max_files_per_operation: 20,
+            cost_limit_usd: 0,
+        },
+    }, null, 2) + '\n';
+}
+//# sourceMappingURL=policy.js.map

package/dist/providers/anthropic.d.ts

@@ -1,6 +1,7 @@
 import { LLMProvider, Message, ToolSchema, StreamEvent, ProviderConfig } from '../types';
 export declare class AnthropicProvider implements LLMProvider {
     name: string;
+    temperature?: number;
     private config;
     constructor(config: ProviderConfig);
     chat(messages: Message[], tools?: ToolSchema[]): AsyncGenerator<StreamEvent>;

package/dist/providers/anthropic.js

@@ -4,6 +4,7 @@ exports.AnthropicProvider = void 0;
 const retry_1 = require("../retry");
 class AnthropicProvider {
     name;
+    temperature;
     config;
     constructor(config) {
         this.config = config;
@@ -22,6 +23,9 @@ class AnthropicProvider {
             max_tokens: 8192,
             stream: true,
         };
+        if (this.temperature !== undefined) {
+            body.temperature = this.temperature;
+        }
         if (systemPrompt) {
             body.system = systemPrompt;
         }

package/dist/providers/openai.d.ts

@@ -1,6 +1,7 @@
 import { LLMProvider, Message, ToolSchema, StreamEvent, ProviderConfig } from '../types';
 export declare class OpenAIProvider implements LLMProvider {
     name: string;
+    temperature?: number;
     private config;
     private supportsTools;
     constructor(config: ProviderConfig);

package/dist/providers/openai.js

@@ -5,6 +5,7 @@ const registry_1 = require("./registry");
 const retry_1 = require("../retry");
 class OpenAIProvider {
     name;
+    temperature;
     config;
     supportsTools;
     constructor(config) {
@@ -25,6 +26,9 @@ class OpenAIProvider {
             messages: messages.map(m => this.formatMessage(m)),
             stream: true,
         };
+        if (this.temperature !== undefined) {
+            body.temperature = this.temperature;
+        }
         if (tools?.length && this.supportsTools) {
             body.tools = tools;
         }

package/dist/replay.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Session Replay Engine for CodeBot v1.8.0
+ *
+ * Replays saved sessions by feeding recorded assistant responses
+ * instead of calling the LLM. Tool calls are re-executed and outputs
+ * compared against recorded results to detect environment divergences.
+ *
+ * Usage:
+ *   codebot --replay <session-id>
+ *   codebot --replay              (replays latest session)
+ */
+import { Message, LLMProvider, ToolSchema, StreamEvent } from './types';
+/**
+ * Mock LLM provider that feeds recorded assistant messages.
+ * Used during replay to bypass actual LLM calls.
+ */
+export declare class ReplayProvider implements LLMProvider {
+    name: string;
+    private assistantMessages;
+    private callIndex;
+    constructor(assistantMessages: Message[]);
+    chat(_messages: Message[], _tools?: ToolSchema[]): AsyncGenerator<StreamEvent>;
+}
+export interface SessionReplayData {
+    messages: Message[];
+    assistantMessages: Message[];
+    userMessages: Message[];
+    toolResults: Map<string, string>;
+}
+/**
+ * Load a session from disk and prepare it for replay.
+ * Returns null if session doesn't exist or is empty.
+ */
+export declare function loadSessionForReplay(sessionId: string): SessionReplayData | null;
+export interface ReplayDivergence {
+    toolCallId: string;
+    toolName: string;
+    type: 'output_mismatch';
+    diff: string;
+}
+/**
+ * Compare recorded vs actual tool output.
+ * Returns null if identical, or a diff description.
+ */
+export declare function compareOutputs(recorded: string, actual: string): string | null;
+/**
+ * List sessions available for replay.
+ */
+export declare function listReplayableSessions(limit?: number): Array<{
+    id: string;
+    preview: string;
+    messageCount: number;
+    date: string;
+}>;
+//# sourceMappingURL=replay.d.ts.map