@bahulam/code 2.6.0

package/src/config/settings.mjs

@@ -0,0 +1,132 @@
+/**
+ * Settings chain — user/project/local/managed (from decompiled source).
+ *
+ * Supports all 76 properties from Claude Code's settings schema.
+ * Five-layer hierarchy: user > project > local > managed > feature flags.
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * Full settings schema with defaults.
+ */
+export const SETTINGS_SCHEMA = {
+    permissions: {
+        defaultMode: 'default',
+        allowRules: [],
+        denyRules: [],
+        allowedTools: [],
+        deniedTools: [],
+        sandbox: true,
+        sandboxAllowPaths: [],
+    },
+    hooks: {
+        PreToolUse: [],
+        PostToolUse: [],
+        PreToolUseFailure: [],
+        PostToolUseFailure: [],
+        Notification: [],
+        Stop: [],
+        SessionStart: [],
+    },
+    model: 'claude-sonnet-4-6',
+    subagentModel: null,
+    fastModel: 'claude-haiku-4-5',
+    fastMode: false,
+    alwaysThinkingEnabled: false,
+    autoCompactEnabled: true,
+    fileCheckpointingEnabled: true,
+    promptSuggestionEnabled: true,
+    briefMode: false,
+    maxContextTokens: 180000,
+    maxOutputTokens: 16384,
+    maxTokens: 16384,
+    thinkingBudget: 10000,
+    compactThreshold: 0.8,
+    stream: true,
+    stagnationDetection: false,
+    stagnationThreshold: 3,
+    mcpServers: {},
+    theme: 'auto',
+    showThinking: false,
+    showToolResults: false,
+    showTokenUsage: true,
+    vimMode: false,
+    terminalBell: false,
+    telemetryEnabled: false,
+    debugMode: false,
+    enableTeams: false,
+    agentId: null,
+    cronEnabled: true,
+    featureFlags: {},
+};
+
+export async function loadSettings() {
+    const chain = [
+        path.join(os.homedir(), '.claude', 'settings.json'),
+        path.join(process.cwd(), '.claude', 'settings.json'),
+        path.join(process.cwd(), '.claude', 'settings.local.json'),
+    ];
+
+    let merged = deepClone(SETTINGS_SCHEMA);
+
+    for (const file of chain) {
+        try {
+            const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            merged = deepMerge(merged, data);
+        } catch {
+            // File not found or invalid
+        }
+    }
+
+    applyEnvOverrides(merged);
+    return merged;
+}
+
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+        if (value && typeof value === 'object' && !Array.isArray(value) && typeof result[key] === 'object' && !Array.isArray(result[key])) {
+            result[key] = deepMerge(result[key] || {}, value);
+        } else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+function applyEnvOverrides(settings) {
+    if (process.env.ANTHROPIC_MODEL) settings.model = process.env.ANTHROPIC_MODEL;
+    if (process.env.CLAUDE_CODE_SUBAGENT_MODEL) settings.subagentModel = process.env.CLAUDE_CODE_SUBAGENT_MODEL;
+    if (process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS) {
+        const n = parseInt(process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS, 10);
+        if (!isNaN(n)) { settings.maxOutputTokens = n; settings.maxTokens = n; }
+    }
+    if (process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS) {
+        const n = parseInt(process.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, 10);
+        if (!isNaN(n)) settings.maxContextTokens = n;
+    }
+    if (process.env.CLAUDE_CODE_BRIEF === '1') settings.briefMode = true;
+    if (process.env.CLAUDE_CODE_DEBUG === '1') settings.debugMode = true;
+    if (process.env.CLAUDE_CODE_PERMISSION_MODE) settings.permissions.defaultMode = process.env.CLAUDE_CODE_PERMISSION_MODE;
+    if (process.env.CLAUDE_CODE_STREAMING === '0') settings.stream = false;
+    if (process.env.CLAUDE_CODE_THINKING === '1') settings.alwaysThinkingEnabled = true;
+    if (process.env.CLAUDE_CODE_DISABLE_CRON === '1') settings.cronEnabled = false;
+    if (process.env.CLAUDE_CODE_ENABLE_TASKS === '1') settings.enableTeams = true;
+    const stagnationEnabled = process.env.KEPLER_STAGNATION_DETECTION;
+    if (stagnationEnabled !== undefined) {
+        settings.stagnationDetection = ['1', 'true', 'yes', 'on'].includes(
+            stagnationEnabled.toLowerCase(),
+        );
+    }
+    const stagnationThreshold = process.env.KEPLER_STAGNATION_THRESHOLD;
+    if (stagnationThreshold) {
+        const n = parseInt(stagnationThreshold, 10);
+        if (Number.isInteger(n) && n >= 2) settings.stagnationThreshold = n;
+    }
+}

package/src/context/ast-parser.mjs

@@ -0,0 +1,298 @@
+/**
+ * AST Parser — Extract structured code knowledge from source files.
+ *
+ * Multi-language regex-based extraction (no tree-sitter dependency).
+ * Returns function signatures, class definitions, imports, exports.
+ *
+ * This is Phase 3 of the Investigative Funnel:
+ * Raw code (2000 tokens) → Structured summary (200 tokens)
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/**
+ * Analyze a source file and return structured knowledge.
+ * @param {string} filePath - absolute path
+ * @param {Object} [options]
+ * @param {number} [options.startLine] - optional line range
+ * @param {number} [options.endLine]
+ * @returns {{ success: boolean, summary: string, structure: Object }}
+ */
+export function analyzeCode(filePath, { startLine, endLine } = {}) {
+  try {
+    let content = fs.readFileSync(filePath, 'utf-8');
+    const totalLines = content.split('\n').length;
+
+    if (startLine || endLine) {
+      const lines = content.split('\n');
+      const start = (startLine || 1) - 1;
+      const end = endLine || lines.length;
+      content = lines.slice(start, end).join('\n');
+    }
+
+    const ext = path.extname(filePath).toLowerCase();
+    const relPath = filePath; // caller should make relative if needed
+
+    let structure;
+    if (['.ts', '.tsx', '.js', '.jsx', '.mjs'].includes(ext)) {
+      structure = parseJavaScriptTypeScript(content);
+    } else if (ext === '.py') {
+      structure = parsePython(content);
+    } else if (ext === '.go') {
+      structure = parseGo(content);
+    } else if (['.rs'].includes(ext)) {
+      structure = parseRust(content);
+    } else {
+      structure = parseGeneric(content);
+    }
+
+    structure.file = path.basename(filePath);
+    structure.lines = totalLines;
+    structure.language = ext.replace('.', '');
+
+    // Build concise summary
+    const summary = buildSummary(structure);
+
+    return { success: true, summary, structure };
+  } catch (err) {
+    return { success: false, summary: `Error analyzing ${filePath}: ${err.message}`, structure: {} };
+  }
+}
+
+// ── JavaScript / TypeScript ────────────────────────────────
+
+function parseJavaScriptTypeScript(content) {
+  const imports = [];
+  const exports = [];
+  const functions = [];
+  const classes = [];
+  const interfaces = [];
+  const types = [];
+  const lines = content.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    const lineNum = i + 1;
+
+    // Imports
+    const importMatch = trimmed.match(/^import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+    if (importMatch) {
+      imports.push({ names: (importMatch[1] || importMatch[2] || '').trim(), from: importMatch[3] });
+      continue;
+    }
+
+    // Exports
+    if (trimmed.startsWith('export default')) {
+      exports.push('default');
+    } else if (trimmed.match(/^export\s+(const|let|var|function|class|interface|type|async)/)) {
+      const nameMatch = trimmed.match(/^export\s+(?:async\s+)?(?:const|let|var|function|class|interface|type)\s+(\w+)/);
+      if (nameMatch) exports.push(nameMatch[1]);
+    }
+
+    // Functions
+    const fnMatch = trimmed.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+    if (fnMatch) {
+      functions.push({ name: fnMatch[1], params: fnMatch[2].trim(), line: lineNum });
+      continue;
+    }
+
+    // Arrow functions
+    const arrowMatch = trimmed.match(/^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*\w+)?\s*=>/);
+    if (arrowMatch) {
+      functions.push({ name: arrowMatch[1], params: arrowMatch[2].trim(), line: lineNum });
+      continue;
+    }
+
+    // Classes
+    const classMatch = trimmed.match(/^(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+    if (classMatch) {
+      classes.push({ name: classMatch[1], extends: classMatch[2] || null, line: lineNum });
+      continue;
+    }
+
+    // Methods
+    const methodMatch = trimmed.match(/^(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*\w+)?\s*\{/);
+    if (methodMatch && !['if', 'for', 'while', 'switch', 'catch'].includes(methodMatch[1])) {
+      functions.push({ name: methodMatch[1], params: methodMatch[2].trim(), line: lineNum, isMethod: true });
+    }
+
+    // Interfaces
+    const ifaceMatch = trimmed.match(/^(?:export\s+)?interface\s+(\w+)/);
+    if (ifaceMatch) interfaces.push({ name: ifaceMatch[1], line: lineNum });
+
+    // Types
+    const typeMatch = trimmed.match(/^(?:export\s+)?type\s+(\w+)\s*=/);
+    if (typeMatch) types.push({ name: typeMatch[1], line: lineNum });
+  }
+
+  return { imports, exports, functions, classes, interfaces, types };
+}
+
+// ── Python ─────────────────────────────────────────────────
+
+function parsePython(content) {
+  const imports = [];
+  const functions = [];
+  const classes = [];
+  const decorators = [];
+  const lines = content.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    const lineNum = i + 1;
+
+    const importMatch = trimmed.match(/^(?:from\s+(\S+)\s+)?import\s+(.+)/);
+    if (importMatch) {
+      imports.push({ from: importMatch[1] || '', names: importMatch[2].trim() });
+      continue;
+    }
+
+    if (trimmed.startsWith('@')) {
+      decorators.push(trimmed);
+      continue;
+    }
+
+    const fnMatch = trimmed.match(/^(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/);
+    if (fnMatch) {
+      functions.push({ name: fnMatch[1], params: fnMatch[2].trim(), line: lineNum });
+      continue;
+    }
+
+    const classMatch = trimmed.match(/^class\s+(\w+)(?:\(([^)]*)\))?/);
+    if (classMatch) {
+      classes.push({ name: classMatch[1], bases: classMatch[2] || '', line: lineNum });
+    }
+  }
+
+  return { imports, functions, classes, decorators };
+}
+
+// ── Go ─────────────────────────────────────────────────────
+
+function parseGo(content) {
+  const imports = [];
+  const functions = [];
+  const structs = [];
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+
+    const importMatch = trimmed.match(/^import\s+"([^"]+)"/);
+    if (importMatch) imports.push(importMatch[1]);
+
+    const fnMatch = trimmed.match(/^func\s+(?:\((\w+)\s+\*?(\w+)\)\s+)?(\w+)\s*\(([^)]*)\)/);
+    if (fnMatch) {
+      functions.push({
+        name: fnMatch[3],
+        params: fnMatch[4]?.trim() || '',
+        receiver: fnMatch[2] || null,
+      });
+    }
+
+    const structMatch = trimmed.match(/^type\s+(\w+)\s+struct/);
+    if (structMatch) structs.push(structMatch[1]);
+  }
+
+  return { imports, functions, structs };
+}
+
+// ── Rust ───────────────────────────────────────────────────
+
+function parseRust(content) {
+  const functions = [];
+  const structs = [];
+  const impls = [];
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+
+    const fnMatch = trimmed.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)\s*\(([^)]*)\)/);
+    if (fnMatch) functions.push({ name: fnMatch[1], params: fnMatch[2].trim() });
+
+    const structMatch = trimmed.match(/^(?:pub\s+)?struct\s+(\w+)/);
+    if (structMatch) structs.push(structMatch[1]);
+
+    const implMatch = trimmed.match(/^impl\s+(?:<[^>]+>\s+)?(\w+)/);
+    if (implMatch) impls.push(implMatch[1]);
+  }
+
+  return { functions, structs, impls };
+}
+
+// ── Generic fallback ───────────────────────────────────────
+
+function parseGeneric(content) {
+  const functions = [];
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    // Try common patterns
+    const fnMatch = trimmed.match(/^(?:(?:pub|public|private|protected|static|async|export)\s+)*(?:function|def|fn|func)\s+(\w+)/);
+    if (fnMatch) functions.push({ name: fnMatch[1] });
+  }
+
+  return { functions };
+}
+
+// ── Summary Builder ────────────────────────────────────────
+
+function buildSummary(structure) {
+  const parts = [];
+  parts.push(`${structure.file} (${structure.lines} lines, ${structure.language})`);
+  parts.push(`Use read_file with start_line/end_line to read specific sections.`);
+  parts.push('');
+
+  if (structure.classes?.length) {
+    for (const cls of structure.classes) {
+      const ext = cls.extends ? ` extends ${cls.extends}` : (cls.bases ? `(${cls.bases})` : '');
+      const ln = cls.line ? ` [line ${cls.line}]` : '';
+      parts.push(`  class ${cls.name}${ext}${ln}`);
+    }
+  }
+
+  if (structure.interfaces?.length) {
+    const ifaceList = structure.interfaces.map(i =>
+      typeof i === 'string' ? i : `${i.name} [line ${i.line}]`
+    ).join(', ');
+    parts.push(`  interfaces: ${ifaceList}`);
+  }
+
+  if (structure.types?.length) {
+    const typeList = structure.types.map(t =>
+      typeof t === 'string' ? t : `${t.name} [line ${t.line}]`
+    ).join(', ');
+    parts.push(`  types: ${typeList}`);
+  }
+
+  if (structure.functions?.length) {
+    for (const fn of structure.functions.slice(0, 20)) {
+      const receiver = fn.receiver ? `(${fn.receiver}) ` : '';
+      const method = fn.isMethod ? '  ' : '';
+      const ln = fn.line ? ` [line ${fn.line}]` : '';
+      parts.push(`${method}  ${receiver}${fn.name}(${fn.params || ''})${ln}`);
+    }
+    if (structure.functions.length > 20) {
+      parts.push(`  ... and ${structure.functions.length - 20} more functions`);
+    }
+  }
+
+  if (structure.structs?.length) {
+    parts.push(`  structs: ${structure.structs.join(', ')}`);
+  }
+
+  if (structure.imports?.length) {
+    const importSummary = structure.imports.slice(0, 5).map(i =>
+      i.from ? `${i.from}` : (typeof i === 'string' ? i : i.names)
+    ).join(', ');
+    const more = structure.imports.length > 5 ? ` +${structure.imports.length - 5} more` : '';
+    parts.push(`  imports: ${importSummary}${more}`);
+  }
+
+  if (structure.exports?.length) {
+    parts.push(`  exports: ${structure.exports.join(', ')}`);
+  }
+
+  return parts.join('\n');
+}

package/src/context/bm25.mjs

@@ -0,0 +1,85 @@
+/**
+ * BM25 Search — T20: Lightweight text search index (~100 LOC).
+ * Parameters: k1=1.2, b=0.75 (standard BM25 tuning).
+ */
+
+export class BM25Index {
+    constructor(k1 = 1.2, b = 0.75) {
+        this.k1 = k1;
+        this.b = b;
+        this.docs = [];      // [{ id, tokens, length }]
+        this.df = new Map();  // term → doc frequency
+        this.avgDl = 0;
+        this.N = 0;
+    }
+
+    /** Tokenize text into lowercase terms. */
+    static tokenize(text) {
+        return text.toLowerCase().match(/[a-z_][a-z0-9_]*/g) || [];
+    }
+
+    /** Add a document to the index. */
+    addDocument(id, text) {
+        const tokens = BM25Index.tokenize(text);
+        const tf = new Map();
+        for (const t of tokens) tf.set(t, (tf.get(t) || 0) + 1);
+        this.docs.push({ id, tf, length: tokens.length });
+
+        for (const term of tf.keys()) {
+            this.df.set(term, (this.df.get(term) || 0) + 1);
+        }
+        this.N = this.docs.length;
+        this.avgDl = this.docs.reduce((s, d) => s + d.length, 0) / this.N;
+    }
+
+    /** Build index from array of { id, text } objects. */
+    buildIndex(documents) {
+        this.docs = [];
+        this.df = new Map();
+        for (const doc of documents) {
+            this.addDocument(doc.id, doc.text);
+        }
+    }
+
+    /** Search for query, return top-K results sorted by BM25 score. */
+    search(query, topK = 10) {
+        const queryTokens = BM25Index.tokenize(query);
+        if (queryTokens.length === 0) return [];
+
+        const scores = [];
+
+        for (const doc of this.docs) {
+            let score = 0;
+            for (const qt of queryTokens) {
+                const tf = doc.tf.get(qt) || 0;
+                if (tf === 0) continue;
+                const dfVal = this.df.get(qt) || 0;
+                const idf = Math.log((this.N - dfVal + 0.5) / (dfVal + 0.5) + 1);
+                const tfNorm = (tf * (this.k1 + 1)) / (tf + this.k1 * (1 - this.b + this.b * doc.length / this.avgDl));
+                score += idf * tfNorm;
+            }
+            if (score > 0) scores.push({ id: doc.id, score });
+        }
+
+        return scores.sort((a, b) => b.score - a.score).slice(0, topK);
+    }
+
+    /** Serialize index to JSON. */
+    toJSON() {
+        return {
+            k1: this.k1, b: this.b, N: this.N, avgDl: this.avgDl,
+            docs: this.docs.map(d => ({ id: d.id, tf: Object.fromEntries(d.tf), length: d.length })),
+            df: Object.fromEntries(this.df),
+        };
+    }
+
+    /** Load index from JSON. */
+    static fromJSON(data) {
+        const idx = new BM25Index(data.k1, data.b);
+        idx.N = data.N;
+        idx.avgDl = data.avgDl;
+        idx.df = new Map(Object.entries(data.df));
+        idx.docs = data.docs.map(d => ({ id: d.id, tf: new Map(Object.entries(d.tf)), length: d.length }));
+        return idx;
+    }
+}