@bahulam/code 2.6.0

package/src/core/trust.mjs

@@ -0,0 +1,158 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { TIERS } from './risk-tier.mjs';
+
+function trustPath(cwd) {
+  return path.join(cwd, '.bahulam', 'trust.json');
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function commandShape(command) {
+  const parts = String(command || '').trim().split(/\s+/).filter(Boolean);
+  return parts.slice(0, 2).join(' ');
+}
+
+function shellPattern(args) {
+  const shape = commandShape(args?.command);
+  return shape ? `${shape}*` : '*';
+}
+
+function pathPattern(args) {
+  const p = String(args?.file_path || args?.path || '').trim();
+  if (!p) return '*';
+  const dir = path.dirname(p);
+  return dir === '.' ? p : path.join(dir, '**');
+}
+
+export function patternFor(tool, args = {}) {
+  if (tool === 'shell') return shellPattern(args);
+  return pathPattern(args);
+}
+
+function matches(pattern, value) {
+  if (!pattern || pattern === '*') return true;
+  if (pattern.endsWith('*')) return String(value || '').startsWith(pattern.slice(0, -1));
+  if (pattern.endsWith('/**')) return String(value || '').startsWith(pattern.slice(0, -3));
+  return pattern === value;
+}
+
+function valueFor(tool, args = {}) {
+  if (tool === 'shell') return String(args.command || '');
+  return String(args.file_path || args.path || '');
+}
+
+export class TrustStore {
+  constructor({ cwd = process.cwd(), policy = {} } = {}) {
+    this.cwd = cwd;
+    this.policy = policy;
+    this.sessionRules = [];
+  }
+
+  loadProjectRules() {
+    try {
+      const file = trustPath(this.cwd);
+      if (!fs.existsSync(file)) return [];
+      const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+      return Array.isArray(data.rules) ? data.rules : [];
+    } catch {
+      return [];
+    }
+  }
+
+  saveProjectRules(rules) {
+    const file = trustPath(this.cwd);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ version: 1, rules }, null, 2) + '\n');
+  }
+
+  allRules() {
+    return [...this.sessionRules, ...this.loadProjectRules()];
+  }
+
+  find(tool, args = {}, tier = '') {
+    const value = valueFor(tool, args);
+    const rules = this.allRules().filter(rule => rule.tool === tool && matches(rule.pattern, value));
+    const deny = rules.find(rule => rule.decision === 'deny');
+    if (deny) return { decision: 'deny', rule: deny };
+    const allow = rules.find(rule => rule.decision === 'allow');
+    if (!allow) return null;
+
+    const reask = this.shouldReask(allow, args, tier);
+    if (reask) return { decision: 'reask', rule: allow, reason: reask };
+    return { decision: 'allow', rule: allow };
+  }
+
+  shouldReask(rule, args = {}, tier = '') {
+    const reask = rule.reask || {};
+    const after = reask.after_minutes ?? this.policy.hitl?.reaskAfterMinutes;
+    if (after && rule.created_at) {
+      const ageMs = Date.now() - Date.parse(rule.created_at);
+      if (Number.isFinite(ageMs) && ageMs > after * 60 * 1000) {
+        return `approval expired after ${after}m`;
+      }
+    }
+    if ((reask.on_risk_increase ?? this.policy.hitl?.reaskOnRiskIncrease) && rule.tier && tier) {
+      const order = [TIERS.READ, TIERS.SHELL_SAFE, TIERS.LOCAL_EDIT, TIERS.SHELL_MEDIUM, TIERS.NETWORK, TIERS.SHELL_DANGEROUS, TIERS.DESTRUCTIVE];
+      if (order.indexOf(tier) > order.indexOf(rule.tier)) return 'risk tier increased';
+    }
+    if ((this.policy.hitl?.alwaysAskForDangerous ?? true) && (tier === TIERS.SHELL_DANGEROUS || tier === TIERS.DESTRUCTIVE)) {
+      return 'dangerous tier requires fresh approval';
+    }
+    if ((reask.on_command_shape_change ?? this.policy.hitl?.reaskOnCommandShapeChange) && rule.command_shape && args.command) {
+      if (rule.command_shape !== commandShape(args.command)) return 'command shape changed';
+    }
+    return '';
+  }
+
+  add({ tool, args = {}, tier, scope = 'SESSION', decision = 'allow' }) {
+    const normalizedScope = String(scope || 'SESSION').toUpperCase();
+    const pattern = patternFor(tool, args);
+    const id = `${tool}-${crypto.createHash('sha1').update(pattern + normalizedScope).digest('hex').slice(0, 10)}`;
+    const ttl = this.policy.hitl?.reaskAfterMinutes ?? 30;
+    const rule = {
+      id,
+      tool,
+      pattern,
+      scope: normalizedScope,
+      decision,
+      tier,
+      command_shape: tool === 'shell' ? commandShape(args.command) : undefined,
+      created_at: nowIso(),
+      expires_at: normalizedScope === 'SESSION'
+        ? new Date(Date.now() + ttl * 60 * 1000).toISOString()
+        : undefined,
+      reask: {
+        after_minutes: ttl,
+        on_command_shape_change: this.policy.hitl?.reaskOnCommandShapeChange ?? true,
+        on_risk_increase: this.policy.hitl?.reaskOnRiskIncrease ?? true,
+        on_path_boundary_change: this.policy.hitl?.reaskOnPathBoundaryChange ?? true,
+      },
+    };
+    if (normalizedScope === 'PROJECT') {
+      const rules = this.loadProjectRules().filter(r => r.id !== id);
+      rules.push(rule);
+      this.saveProjectRules(rules);
+    } else {
+      this.sessionRules = this.sessionRules.filter(r => r.id !== id);
+      this.sessionRules.push(rule);
+    }
+    return rule;
+  }
+
+  revoke() {
+    const active = this.sessionRules.length > 0;
+    this.sessionRules = [];
+    return active;
+  }
+
+  summary() {
+    return {
+      sessionRules: this.sessionRules.length,
+      projectRules: this.loadProjectRules().length,
+    };
+  }
+}

package/src/core/work-scope.mjs

@@ -0,0 +1,248 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+const SCHEMA = 'kepler.work_scope/1';
+const ROOT_MARKERS = [
+    '.bahulam',
+    '.git',
+    'package.json',
+    'pyproject.toml',
+    'setup.py',
+    'go.mod',
+    'Cargo.toml',
+];
+
+function stable(value) {
+    if (Array.isArray(value)) return value.map(stable);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(
+            Object.entries(value)
+                .filter(([, v]) => v !== undefined)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([k, v]) => [k, stable(v)]),
+        );
+    }
+    return value;
+}
+
+function sha(payload) {
+    return crypto
+        .createHash('sha256')
+        .update(JSON.stringify(stable(payload)))
+        .digest('hex')
+        .slice(0, 16);
+}
+
+function normalizePathInput(value) {
+    let s = String(value || '').trim();
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+        s = s.slice(1, -1);
+    }
+    if (s === '~' || s.startsWith('~/')) {
+        s = path.join(os.homedir(), s.slice(1));
+    }
+    return s.replace(/\\([ \t()&$;'"])/g, '$1');
+}
+
+function nearestProjectRoot(candidate) {
+    let resolved = normalizePathInput(candidate);
+    if (!resolved || !path.isAbsolute(resolved)) return null;
+
+    try {
+        resolved = fs.realpathSync(resolved);
+    } catch {
+        return null;
+    }
+
+    let dir = resolved;
+    try {
+        if (fs.statSync(resolved).isFile()) dir = path.dirname(resolved);
+    } catch {
+        return null;
+    }
+
+    const root = path.parse(dir).root;
+    let current = dir;
+    while (current && current !== root) {
+        if (ROOT_MARKERS.some(marker => fs.existsSync(path.join(current, marker)))) {
+            return fs.realpathSync(current);
+        }
+        current = path.dirname(current);
+    }
+    return fs.realpathSync(dir);
+}
+
+function extractQuotedPaths(text) {
+    const paths = [];
+    const re = /(['"])(\/[^'"\n]+)\1/g;
+    let match;
+    while ((match = re.exec(String(text || ''))) !== null) {
+        paths.push(match[2]);
+    }
+    return paths;
+}
+
+function isInsideQuotedSpan(source, index) {
+    let quote = null;
+    let escaped = false;
+    for (let i = 0; i < index; i++) {
+        const ch = source[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escaped = true;
+            continue;
+        }
+        if ((ch === '"' || ch === "'")) {
+            quote = quote === ch ? null : (quote || ch);
+        }
+    }
+    return Boolean(quote);
+}
+
+function extractPastedPaths(text) {
+    const source = String(text || '');
+    const paths = [];
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] !== '/') continue;
+        if (isInsideQuotedSpan(source, i)) continue;
+        const line = source.slice(i).split(/\r?\n/, 1)[0].replace(/[),.;:]+$/g, '');
+        const parts = line.split(/\s+/).filter(Boolean);
+        let candidate = '';
+        let lastRoot = null;
+        for (const part of parts.slice(0, 12)) {
+            candidate = candidate ? `${candidate} ${part}` : part;
+            const root = nearestProjectRoot(candidate.replace(/[),.;:]+$/g, ''));
+            if (root) lastRoot = root;
+        }
+        if (lastRoot) paths.push(lastRoot);
+    }
+    return paths;
+}
+
+function uniqueRoots(entries) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of entries) {
+        if (!entry?.path || seen.has(entry.path)) continue;
+        seen.add(entry.path);
+        result.push(entry);
+    }
+    return result;
+}
+
+export function promptProjectRoots(instruction = '') {
+    const roots = [];
+    const seen = new Set();
+    for (const raw of [...extractQuotedPaths(instruction), ...extractPastedPaths(instruction)]) {
+        const root = nearestProjectRoot(raw);
+        if (!root || seen.has(root)) continue;
+        seen.add(root);
+        roots.push(root);
+    }
+    return roots;
+}
+
+function roleForRoot(root, cwd) {
+    const base = path.basename(root).toLowerCase();
+    if (base.includes('backend')) return 'backend';
+    if (base.includes('frontend') || base.includes('web')) return 'frontend';
+    if (base.includes('deploy')) return 'deploy';
+    if (base.includes('docs') || base.includes('prd')) return 'docs';
+    if (base.includes('npm') || base.includes('cli')) return 'cli';
+    if (root === cwd) return 'primary';
+    return 'workspace';
+}
+
+function truncate(value, max = 280) {
+    const s = String(value || '').replace(/\s+/g, ' ').trim();
+    return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+
+function sortedResources(resources) {
+    return (Array.isArray(resources) ? resources : [])
+        .filter(resource => resource && resource.root)
+        .map(resource => ({
+            project_id: String(resource.project_id || ''),
+            root: String(resource.root || ''),
+            name: String(resource.name || path.basename(String(resource.root || ''))),
+            index_version: String(resource.index_version || ''),
+        }))
+        .sort((a, b) => a.root.localeCompare(b.root));
+}
+
+export function buildWorkScope({
+    instruction = '',
+    cwd = process.cwd(),
+    projectResources = [],
+} = {}) {
+    const cwdRoot = nearestProjectRoot(cwd) || path.resolve(cwd);
+    const roots = [{
+        path: cwdRoot,
+        role: roleForRoot(cwdRoot, cwdRoot),
+        source: 'cwd',
+        status: 'active',
+    }];
+
+    for (const root of promptProjectRoots(instruction)) {
+        roots.push({
+            path: root,
+            role: roleForRoot(root, cwdRoot),
+            source: 'prompt',
+            status: 'active',
+        });
+    }
+
+    for (const resource of sortedResources(projectResources)) {
+        roots.push({
+            path: resource.root,
+            role: roleForRoot(resource.root, cwdRoot),
+            source: 'registered',
+            status: 'active',
+            project_id: resource.project_id || undefined,
+        });
+    }
+
+    const activeRoots = uniqueRoots(roots);
+    const resources = sortedResources(projectResources);
+    const scope = {
+        schema: SCHEMA,
+        primary_root: cwdRoot,
+        intent: truncate(instruction),
+        active_roots: activeRoots,
+        candidate_roots: [],
+        workspace_resources: resources,
+        cache_policy: {
+            stable_system: false,
+            placement: 'pinned_context',
+            reason: 'scope changes with user intent and discovered roots',
+        },
+    };
+    scope.version = sha({
+        schema: scope.schema,
+        primary_root: scope.primary_root,
+        intent: scope.intent,
+        active_roots: scope.active_roots,
+        workspace_resources: scope.workspace_resources,
+    });
+    return scope;
+}
+
+export function summarizeWorkScope(scope) {
+    if (!scope || typeof scope !== 'object') return '';
+    const roots = Array.isArray(scope.active_roots) ? scope.active_roots : [];
+    const lines = [
+        `Work scope ${scope.version || 'unknown'}`,
+        `Primary: ${scope.primary_root || '(unknown)'}`,
+    ];
+    if (scope.intent) lines.push(`Intent: ${scope.intent}`);
+    for (const root of roots) {
+        if (!root?.path) continue;
+        lines.push(`- ${root.path} [${root.role || 'workspace'}; ${root.source || 'unknown'}]`);
+    }
+    return lines.join('\n');
+}

package/src/hooks/engine.mjs

@@ -0,0 +1,162 @@
+/**
+ * Hook Engine — pre/post tool use and stop hooks.
+ *
+ * Based on Claude Code's hooks system (6 event types):
+ * - PreToolUse: can block tool execution
+ * - PostToolUse: can modify results
+ * - Stop: can prevent the agent from stopping
+ * - Notification: inform external systems
+ * - PrePrompt: modify user input
+ * - PostResponse: modify assistant output
+ *
+ * Hooks are defined in settings.json under the "hooks" key.
+ */
+
+import { execSync } from 'child_process';
+
+export class HookEngine {
+    /**
+     * @param {object} hooksConfig - hooks configuration from settings
+     */
+    constructor(hooksConfig = {}) {
+        this.hooks = hooksConfig;
+    }
+
+    /**
+     * Run pre-tool-use hooks. Returns { allow, message }.
+     * If any hook returns deny, the tool call is blocked.
+     *
+     * @param {string} toolName - name of the tool being called
+     * @param {object} input - tool input arguments
+     * @returns {Promise<{allow: boolean, message?: string}>}
+     */
+    async runPreToolUse(toolName, input) {
+        const hooks = this._getHooks('PreToolUse');
+        for (const hook of hooks) {
+            // Check if hook applies to this tool
+            if (hook.toolName && hook.toolName !== toolName) continue;
+
+            const result = await this._executeHook(hook, {
+                event: 'PreToolUse',
+                toolName,
+                input,
+            });
+
+            if (result?.decision === 'deny' || result?.decision === 'block') {
+                return { allow: false, message: result.message || `Blocked by hook: ${hook.name || 'unnamed'}` };
+            }
+        }
+        return { allow: true };
+    }
+
+    /**
+     * Run post-tool-use hooks. Can modify the result.
+     *
+     * @param {string} toolName - name of the tool that was called
+     * @param {*} result - tool execution result
+     * @returns {Promise<*>} possibly modified result
+     */
+    async runPostToolUse(toolName, result) {
+        const hooks = this._getHooks('PostToolUse');
+        let current = result;
+        for (const hook of hooks) {
+            if (hook.toolName && hook.toolName !== toolName) continue;
+
+            const hookResult = await this._executeHook(hook, {
+                event: 'PostToolUse',
+                toolName,
+                result: current,
+            });
+
+            if (hookResult?.modifiedResult !== undefined) {
+                current = hookResult.modifiedResult;
+            }
+        }
+        return current;
+    }
+
+    /**
+     * Run stop hooks. Returns true if stop should proceed, false to continue.
+     *
+     * @returns {Promise<boolean>} whether to allow stopping
+     */
+    async runStop() {
+        const hooks = this._getHooks('Stop');
+        for (const hook of hooks) {
+            const result = await this._executeHook(hook, { event: 'Stop' });
+            if (result?.preventStop) {
+                return false; // do not stop
+            }
+        }
+        return true; // allow stop
+    }
+
+    /**
+     * Run notification hooks (fire-and-forget).
+     * @param {string} event - notification event name
+     * @param {object} data - event data
+     */
+    async runNotification(event, data) {
+        const hooks = this._getHooks('Notification');
+        for (const hook of hooks) {
+            try {
+                await this._executeHook(hook, { event, ...data });
+            } catch {
+                // Notifications are best-effort
+            }
+        }
+    }
+
+    /**
+     * Get hooks for a given event type.
+     * @param {string} eventType
+     * @returns {Array}
+     */
+    _getHooks(eventType) {
+        if (!this.hooks || !this.hooks[eventType]) return [];
+        const hooks = this.hooks[eventType];
+        return Array.isArray(hooks) ? hooks : [hooks];
+    }
+
+    /**
+     * Execute a single hook. Supports command (shell) and function hooks.
+     *
+     * @param {object} hook - hook definition
+     * @param {object} context - execution context
+     * @returns {Promise<object|null>}
+     */
+    async _executeHook(hook, context) {
+        try {
+            if (hook.command) {
+                const env = {
+                    ...process.env,
+                    HOOK_EVENT: context.event,
+                    HOOK_TOOL: context.toolName || '',
+                    HOOK_INPUT: JSON.stringify(context.input || {}),
+                };
+                const output = execSync(hook.command, {
+                    encoding: 'utf-8',
+                    timeout: hook.timeout || 10000,
+                    env,
+                });
+                try {
+                    return JSON.parse(output.trim());
+                } catch {
+                    return { output: output.trim() };
+                }
+            }
+
+            if (typeof hook.handler === 'function') {
+                return await hook.handler(context);
+            }
+
+            return null;
+        } catch (err) {
+            if (hook.failOpen !== false) {
+                // Default: fail open (allow)
+                return null;
+            }
+            return { decision: 'deny', message: `Hook error: ${err.message}` };
+        }
+    }
+}