@revealui/ai 0.1.3 → 0.2.2

package/dist/tools/coding/git-ops.js

@@ -0,0 +1,102 @@
+/**
+ * git_ops — Git operations wrapper (status, diff, log, blame)
+ */
+import { execSync } from 'node:child_process';
+import { z } from 'zod/v4';
+import { getSafetyConfig } from './safety.js';
+const GIT_OPERATIONS = ['status', 'diff', 'diff_full', 'log', 'blame', 'show', 'branch'];
+/** Max output per git command */
+const MAX_OUTPUT = 50_000;
+function runGit(args, cwd) {
+    const cmd = `git ${args.join(' ')}`;
+    return execSync(cmd, {
+        cwd,
+        timeout: 15_000,
+        maxBuffer: MAX_OUTPUT,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: '0',
+            // Prevent pager from blocking
+            GIT_PAGER: 'cat',
+        },
+    }).trim();
+}
+export const gitOpsTool = {
+    name: 'git_ops',
+    label: 'Git Operations',
+    description: 'Run read-only git operations: status, diff (summary), diff_full (full patch), log, blame, show, branch. Safe operations only — no push, commit, reset, or checkout.',
+    parameters: z.object({
+        operation: z.enum(GIT_OPERATIONS).describe('Git operation to perform'),
+        args: z
+            .array(z.string())
+            .optional()
+            .describe('Additional arguments (e.g., ["--oneline", "-n", "10"] for log)'),
+    }),
+    async execute(params) {
+        const { operation, args = [] } = params;
+        const config = getSafetyConfig();
+        // Block any sneaky write operations passed as args
+        const joinedArgs = args.join(' ');
+        const dangerousFlags = ['--force', '--hard', '--delete', '-D', '--push'];
+        for (const flag of dangerousFlags) {
+            if (joinedArgs.toLowerCase().includes(flag.toLowerCase())) {
+                return {
+                    success: false,
+                    error: `Dangerous flag "${flag}" not allowed in git_ops. This tool is read-only.`,
+                };
+            }
+        }
+        try {
+            let output;
+            switch (operation) {
+                case 'status':
+                    output = runGit(['status', '--short', ...args], config.projectRoot);
+                    break;
+                case 'diff':
+                    output = runGit(['diff', '--stat', ...args], config.projectRoot);
+                    break;
+                case 'diff_full':
+                    // Full patch content for code review — hunks per file
+                    output = runGit(['diff', '--no-color', '-U3', ...args], config.projectRoot);
+                    break;
+                case 'log':
+                    // Default: last 20 commits, oneline
+                    if (args.length === 0) {
+                        output = runGit(['log', '--oneline', '--decorate', '-n', '20'], config.projectRoot);
+                    }
+                    else {
+                        output = runGit(['log', ...args], config.projectRoot);
+                    }
+                    break;
+                case 'blame':
+                    if (args.length === 0) {
+                        return { success: false, error: 'blame requires a file path argument' };
+                    }
+                    output = runGit(['blame', '--line-porcelain', ...args], config.projectRoot);
+                    break;
+                case 'show':
+                    output = runGit(['show', '--stat', ...args], config.projectRoot);
+                    break;
+                case 'branch':
+                    output = runGit(['branch', '-a', '--no-color', ...args], config.projectRoot);
+                    break;
+            }
+            const lines = output.split('\n').length;
+            return {
+                success: true,
+                data: { operation, output },
+                content: output.length > 3000
+                    ? `git ${operation} (${lines} lines, truncated):\n${output.slice(0, 3000)}…`
+                    : `git ${operation}:\n${output}`,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                error: `git ${operation} failed: ${message.slice(0, 500)}`,
+            };
+        }
+    },
+};

package/dist/tools/coding/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Coding Tools Package
+ * File operations, search, shell, git, and project context tools
+ * for the RevealUI standalone coding agent.
+ */
+import type { Tool } from '../base.js';
+export { fileEditTool } from './file-edit.js';
+export { fileGlobTool } from './file-glob.js';
+export { fileGrepTool } from './file-grep.js';
+export { fileReadTool } from './file-read.js';
+export { fileWriteTool } from './file-write.js';
+export { gitOpsTool } from './git-ops.js';
+export { lintFixTool } from './lint-fix.js';
+export { projectContextTool } from './project-context.js';
+export type { SafetyConfig } from './safety.js';
+export { configureSafety, getSafetyConfig, resolveSafePath, validateCommand, validatePath, } from './safety.js';
+export { shellExecTool } from './shell-exec.js';
+export { testRunnerTool } from './test-runner.js';
+/**
+ * Configuration for the coding tools factory
+ */
+export interface CodingToolsConfig {
+    /** Project root directory — all file operations sandboxed here */
+    projectRoot: string;
+    /** Additional directories to allow (e.g., /tmp for scratch files) */
+    allowedPaths?: string[];
+    /** Extra commands to deny beyond the built-in denylist */
+    extraDeniedCommands?: string[];
+    /** Extra path patterns to deny */
+    deniedPathPatterns?: RegExp[];
+    /** Which tools to include (default: all) */
+    include?: Array<'file_read' | 'file_write' | 'file_edit' | 'file_glob' | 'file_grep' | 'shell_exec' | 'git_ops' | 'project_context' | 'test_runner' | 'lint_fix'>;
+}
+/**
+ * Create coding tools with safety configuration applied.
+ *
+ * Must be called before any tool execution to establish the project root sandbox.
+ */
+export declare function createCodingTools(config: CodingToolsConfig): Tool[];
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/coding/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/coding/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAevC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,eAAe,EACf,eAAe,EACf,eAAe,EACf,eAAe,EACf,YAAY,GACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,0DAA0D;IAC1D,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,kCAAkC;IAClC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,4CAA4C;IAC5C,OAAO,CAAC,EAAE,KAAK,CACX,WAAW,GACX,YAAY,GACZ,WAAW,GACX,WAAW,GACX,WAAW,GACX,YAAY,GACZ,SAAS,GACT,iBAAiB,GACjB,aAAa,GACb,UAAU,CACb,CAAC;CACH;AAgBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,EAAE,CAmBnE"}

package/dist/tools/coding/index.js

@@ -0,0 +1,62 @@
+/**
+ * Coding Tools Package
+ * File operations, search, shell, git, and project context tools
+ * for the RevealUI standalone coding agent.
+ */
+import { fileEditTool } from './file-edit.js';
+import { fileGlobTool } from './file-glob.js';
+import { fileGrepTool } from './file-grep.js';
+import { fileReadTool } from './file-read.js';
+import { fileWriteTool } from './file-write.js';
+import { gitOpsTool } from './git-ops.js';
+import { lintFixTool } from './lint-fix.js';
+import { projectContextTool } from './project-context.js';
+import { configureSafety } from './safety.js';
+import { shellExecTool } from './shell-exec.js';
+import { testRunnerTool } from './test-runner.js';
+// Re-export individual tools
+export { fileEditTool } from './file-edit.js';
+export { fileGlobTool } from './file-glob.js';
+export { fileGrepTool } from './file-grep.js';
+export { fileReadTool } from './file-read.js';
+export { fileWriteTool } from './file-write.js';
+export { gitOpsTool } from './git-ops.js';
+export { lintFixTool } from './lint-fix.js';
+export { projectContextTool } from './project-context.js';
+export { configureSafety, getSafetyConfig, resolveSafePath, validateCommand, validatePath, } from './safety.js';
+export { shellExecTool } from './shell-exec.js';
+export { testRunnerTool } from './test-runner.js';
+/** All coding tools in registration order */
+const ALL_CODING_TOOLS = [
+    fileReadTool,
+    fileWriteTool,
+    fileEditTool,
+    fileGlobTool,
+    fileGrepTool,
+    shellExecTool,
+    gitOpsTool,
+    projectContextTool,
+    testRunnerTool,
+    lintFixTool,
+];
+/**
+ * Create coding tools with safety configuration applied.
+ *
+ * Must be called before any tool execution to establish the project root sandbox.
+ */
+export function createCodingTools(config) {
+    // Configure the safety module
+    const safetyConfig = {
+        projectRoot: config.projectRoot,
+        allowedPaths: config.allowedPaths,
+        extraDeniedCommands: config.extraDeniedCommands,
+        deniedPathPatterns: config.deniedPathPatterns,
+    };
+    configureSafety(safetyConfig);
+    // Filter tools if include list is provided
+    if (config.include) {
+        const includeSet = new Set(config.include);
+        return ALL_CODING_TOOLS.filter((t) => includeSet.has(t.name));
+    }
+    return [...ALL_CODING_TOOLS];
+}

package/dist/tools/coding/lint-fix.d.ts

@@ -0,0 +1,9 @@
+/**
+ * lint_fix — Run linter and optionally auto-fix issues
+ *
+ * Detects the linter (Biome, ESLint) and runs it with machine-parseable
+ * output. Returns structured diagnostic counts and details.
+ */
+import type { Tool } from '../base.js';
+export declare const lintFixTool: Tool;
+//# sourceMappingURL=lint-fix.d.ts.map

package/dist/tools/coding/lint-fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-fix.d.ts","sourceRoot":"","sources":["../../../src/tools/coding/lint-fix.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,IAAI,EAAc,MAAM,YAAY,CAAC;AAwMnD,eAAO,MAAM,WAAW,EAAE,IAqHzB,CAAC"}

package/dist/tools/coding/lint-fix.js

@@ -0,0 +1,256 @@
+/**
+ * lint_fix — Run linter and optionally auto-fix issues
+ *
+ * Detects the linter (Biome, ESLint) and runs it with machine-parseable
+ * output. Returns structured diagnostic counts and details.
+ */
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod/v4';
+import { getSafetyConfig } from './safety.js';
+/** Default timeout: 60 seconds */
+const DEFAULT_TIMEOUT_MS = 60_000;
+/** Max output: 200KB */
+const MAX_OUTPUT_BYTES = 200 * 1024;
+function detectLinter(projectRoot) {
+    // Check for Biome config
+    if (existsSync(join(projectRoot, 'biome.json')) || existsSync(join(projectRoot, 'biome.jsonc'))) {
+        return 'biome';
+    }
+    // Check package.json devDependencies
+    const pkgPath = join(projectRoot, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(execSync(`cat "${pkgPath}"`, { encoding: 'utf8', timeout: 5000 }));
+            const deps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            if (deps['@biomejs/biome'])
+                return 'biome';
+            if (deps.eslint)
+                return 'eslint';
+        }
+        catch {
+            // Fall through
+        }
+    }
+    return 'unknown';
+}
+function buildCommand(linter, file, fix) {
+    const target = file ?? '.';
+    switch (linter) {
+        case 'biome':
+            return fix ? `npx biome check --write ${target}` : `npx biome check ${target}`;
+        case 'eslint':
+            return fix
+                ? `npx eslint ${target} --fix --format json`
+                : `npx eslint ${target} --format json`;
+        default:
+            // Try pnpm lint as fallback
+            return fix ? 'pnpm lint:fix' : 'pnpm lint';
+    }
+}
+function parseBiomeOutput(output) {
+    const diagnostics = [];
+    // Parse Biome diagnostic lines: "path/file.ts:line:col lint/rule ━━━"
+    // and "path/file.ts:line:col organize_imports ━━━"
+    const diagRegex = /^(.+?):(\d+):(\d+)\s+(\S+)/gm;
+    let match = diagRegex.exec(output);
+    while (match !== null) {
+        const file = match[1] ?? '';
+        const line = Number.parseInt(match[2] ?? '0', 10);
+        const column = Number.parseInt(match[3] ?? '0', 10);
+        const rule = match[4];
+        // Extract message from the next meaningful line
+        const afterMatch = output.slice((match.index ?? 0) + match[0].length);
+        const msgMatch = afterMatch.match(/\n\s*[×✖!⚠ℹ]\s*(.+)/);
+        const message = msgMatch?.[1]?.trim() ?? rule ?? '';
+        const severity = /error|×|✖/.test(afterMatch.slice(0, 100))
+            ? 'error'
+            : 'warning';
+        diagnostics.push({
+            file,
+            line,
+            column,
+            severity,
+            rule,
+            message: message.slice(0, 200),
+        });
+        match = diagRegex.exec(output);
+    }
+    // Parse summary: "Found N errors." or "Checked N file(s). No errors found."
+    const errorCountMatch = output.match(/Found\s+(\d+)\s+error/i);
+    const warningCountMatch = output.match(/Found\s+(\d+)\s+warning/i);
+    const fixableMatch = output.match(/(\d+)\s+(?:fixable|fix(?:ed)?)/i);
+    const errors = errorCountMatch
+        ? Number.parseInt(errorCountMatch[1] ?? '0', 10)
+        : diagnostics.filter((d) => d.severity === 'error').length;
+    const warnings = warningCountMatch
+        ? Number.parseInt(warningCountMatch[1] ?? '0', 10)
+        : diagnostics.filter((d) => d.severity === 'warning').length;
+    const fixable = fixableMatch ? Number.parseInt(fixableMatch[1] ?? '0', 10) : 0;
+    return {
+        errors,
+        warnings,
+        fixable,
+        total: errors + warnings,
+        diagnostics,
+    };
+}
+function parseEslintOutput(output) {
+    const diagnostics = [];
+    let errors = 0;
+    let warnings = 0;
+    let fixable = 0;
+    try {
+        // ESLint JSON format
+        const results = JSON.parse(output);
+        for (const result of results) {
+            errors += result.errorCount;
+            warnings += result.warningCount;
+            fixable += result.fixableErrorCount + result.fixableWarningCount;
+            for (const msg of result.messages.slice(0, 20)) {
+                diagnostics.push({
+                    file: result.filePath,
+                    line: msg.line,
+                    column: msg.column,
+                    severity: msg.severity === 2 ? 'error' : 'warning',
+                    rule: msg.ruleId ?? undefined,
+                    message: msg.message.slice(0, 200),
+                });
+            }
+        }
+    }
+    catch {
+        // Fall back to generic parsing
+        return parseGenericOutput(output);
+    }
+    return { errors, warnings, fixable, total: errors + warnings, diagnostics };
+}
+function parseGenericOutput(output) {
+    const diagnostics = [];
+    // Generic pattern: file:line:col: severity message
+    const lineRegex = /^(.+?):(\d+):(\d+):\s*(error|warning|info)\s+(.+)/gm;
+    let match = lineRegex.exec(output);
+    while (match !== null) {
+        diagnostics.push({
+            file: match[1] ?? '',
+            line: Number.parseInt(match[2] ?? '0', 10),
+            column: Number.parseInt(match[3] ?? '0', 10),
+            severity: (match[4] ?? 'error'),
+            message: (match[5] ?? '').slice(0, 200),
+        });
+        match = lineRegex.exec(output);
+    }
+    const errors = diagnostics.filter((d) => d.severity === 'error').length;
+    const warnings = diagnostics.filter((d) => d.severity === 'warning').length;
+    return {
+        errors,
+        warnings,
+        fixable: 0,
+        total: errors + warnings,
+        diagnostics,
+    };
+}
+export const lintFixTool = {
+    name: 'lint_fix',
+    label: 'Lint & Fix',
+    description: 'Run the project linter and return structured diagnostics. Auto-detects Biome or ESLint. Can optionally auto-fix issues. Returns error/warning counts and individual diagnostic details.',
+    parameters: z.object({
+        file: z
+            .string()
+            .optional()
+            .describe('Specific file or directory to lint (default: entire project)'),
+        fix: z.boolean().optional().describe('Auto-fix fixable issues (default: false)'),
+        timeout: z
+            .number()
+            .optional()
+            .describe(`Timeout in milliseconds (default: ${DEFAULT_TIMEOUT_MS}, max: 300000)`),
+    }),
+    async execute(params) {
+        const { file, fix, timeout } = params;
+        const config = getSafetyConfig();
+        const timeoutMs = Math.min(timeout ?? DEFAULT_TIMEOUT_MS, 300_000);
+        const linter = detectLinter(config.projectRoot);
+        const command = buildCommand(linter, file, fix);
+        let stdout = '';
+        let stderr = '';
+        let exitCode = 0;
+        try {
+            stdout = execSync(command, {
+                cwd: config.projectRoot,
+                timeout: timeoutMs,
+                maxBuffer: MAX_OUTPUT_BYTES,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: {
+                    ...process.env,
+                    FORCE_COLOR: '0',
+                    NO_COLOR: '1',
+                },
+            });
+        }
+        catch (err) {
+            const execErr = err;
+            if (execErr.killed || execErr.signal === 'SIGTERM') {
+                return {
+                    success: false,
+                    error: `Linting timed out after ${timeoutMs}ms`,
+                    data: {
+                        linter,
+                        command,
+                        exitCode: -1,
+                        summary: { errors: 0, warnings: 0, fixable: 0, total: 0, diagnostics: [] },
+                    },
+                };
+            }
+            exitCode = execErr.status ?? 1;
+            stdout = (execErr.stdout ?? '').toString();
+            stderr = (execErr.stderr ?? '').toString();
+        }
+        const combined = [stdout, stderr].filter(Boolean).join('\n');
+        // Parse results
+        let summary;
+        switch (linter) {
+            case 'biome':
+                summary = parseBiomeOutput(combined);
+                break;
+            case 'eslint':
+                summary = parseEslintOutput(combined);
+                break;
+            default:
+                summary = parseGenericOutput(combined);
+        }
+        // Build token-efficient content
+        const statusIcon = summary.errors > 0 ? '✗' : summary.warnings > 0 ? '⚠' : '✓';
+        const lines = [
+            `${statusIcon} Lint: ${summary.errors} errors, ${summary.warnings} warnings (${summary.total} total)`,
+        ];
+        if (summary.fixable > 0)
+            lines.push(`Fixable: ${summary.fixable}`);
+        if (fix)
+            lines.push('Mode: auto-fix applied');
+        if (file)
+            lines.push(`Target: ${file}`);
+        lines.push(`Linter: ${linter}`);
+        if (summary.diagnostics.length > 0) {
+            lines.push('', 'Diagnostics:');
+            for (const d of summary.diagnostics.slice(0, 15)) {
+                const loc = d.line ? `:${d.line}${d.column ? `:${d.column}` : ''}` : '';
+                const rule = d.rule ? ` [${d.rule}]` : '';
+                lines.push(`  ${d.severity === 'error' ? '✗' : '⚠'} ${d.file}${loc}${rule}`);
+                lines.push(`    ${d.message}`);
+            }
+            if (summary.diagnostics.length > 15) {
+                lines.push(`  ... and ${summary.diagnostics.length - 15} more`);
+            }
+        }
+        return {
+            success: summary.errors === 0,
+            data: { linter, command, exitCode, summary },
+            content: lines.join('\n'),
+        };
+    },
+};

package/dist/tools/coding/project-context.d.ts

@@ -0,0 +1,6 @@
+/**
+ * project_context — Query the harness content layer for relevant project rules and skills
+ */
+import type { Tool } from '../base.js';
+export declare const projectContextTool: Tool;
+//# sourceMappingURL=project-context.d.ts.map

package/dist/tools/coding/project-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-context.d.ts","sourceRoot":"","sources":["../../../src/tools/coding/project-context.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,IAAI,EAAc,MAAM,YAAY,CAAC;AAuFnD,eAAO,MAAM,kBAAkB,EAAE,IAkDhC,CAAC"}

package/dist/tools/coding/project-context.js

@@ -0,0 +1,126 @@
+/**
+ * project_context — Query the harness content layer for relevant project rules and skills
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod/v4';
+import { getSafetyConfig } from './safety.js';
+/** Search content definitions for relevant context */
+function searchContent(projectRoot, query, scope) {
+    const results = [];
+    const queryLower = query.toLowerCase();
+    const queryTerms = queryLower.split(/\s+/);
+    // Content directories to search (harness content layer paths)
+    const searchDirs = [
+        { dir: join(projectRoot, '.claude', 'rules'), type: 'rule' },
+        { dir: join(projectRoot, '.claude', 'agents'), type: 'agent' },
+        { dir: join(projectRoot, '.claude', 'commands'), type: 'command' },
+    ];
+    // If scope is specified, filter to that type
+    const filteredDirs = scope ? searchDirs.filter((d) => d.type === scope) : searchDirs;
+    for (const { dir, type } of filteredDirs) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    // Check for skill directories with SKILL.md
+                    const skillPath = join(fullPath, 'SKILL.md');
+                    try {
+                        const content = readFileSync(skillPath, 'utf8');
+                        if (matchesQuery(content, queryTerms)) {
+                            results.push({
+                                id: entry,
+                                type: 'skill',
+                                path: skillPath.replace(`${projectRoot}/`, ''),
+                                content,
+                            });
+                        }
+                    }
+                    catch {
+                        // Not a skill directory, skip
+                    }
+                }
+                else if (entry.endsWith('.md')) {
+                    const content = readFileSync(fullPath, 'utf8');
+                    if (matchesQuery(content, queryTerms)) {
+                        results.push({
+                            id: entry.replace('.md', ''),
+                            type,
+                            path: fullPath.replace(`${projectRoot}/`, ''),
+                            content,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Directory not readable or does not exist — skip silently
+            }
+        }
+    }
+    // Score by relevance (number of query terms found)
+    results.sort((a, b) => {
+        const scoreA = queryTerms.filter((t) => a.content.toLowerCase().includes(t)).length;
+        const scoreB = queryTerms.filter((t) => b.content.toLowerCase().includes(t)).length;
+        return scoreB - scoreA;
+    });
+    return results;
+}
+function matchesQuery(content, terms) {
+    const lower = content.toLowerCase();
+    // Match if at least one term is found
+    return terms.some((term) => lower.includes(term));
+}
+export const projectContextTool = {
+    name: 'project_context',
+    label: 'Project Context',
+    description: "Query the project's harness content layer for relevant rules, agents, commands, and skills. Use this to understand project conventions, coding standards, and available tools before making changes.",
+    parameters: z.object({
+        query: z
+            .string()
+            .describe('Search query (e.g., "database conventions", "testing patterns", "auth")'),
+        scope: z
+            .enum(['rule', 'agent', 'command', 'skill'])
+            .optional()
+            .describe('Limit search to a specific content type'),
+    }),
+    async execute(params) {
+        const { query, scope } = params;
+        const config = getSafetyConfig();
+        try {
+            const results = searchContent(config.projectRoot, query, scope);
+            if (results.length === 0) {
+                return {
+                    success: true,
+                    data: { query, results: [] },
+                    content: `No project context found for "${query}"`,
+                };
+            }
+            // Return top 5 most relevant results
+            const top = results.slice(0, 5);
+            const summaries = top.map((item) => {
+                // Truncate content for token efficiency
+                const preview = item.content.length > 500 ? `${item.content.slice(0, 500)}…` : item.content;
+                return `[${item.type}] ${item.id} (${item.path}):\n${preview}`;
+            });
+            return {
+                success: true,
+                data: { query, resultCount: results.length, results: top },
+                content: `Found ${results.length} results for "${query}" (showing top ${top.length}):\n\n${summaries.join('\n\n---\n\n')}`,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Context query failed: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    },
+};

package/dist/tools/coding/safety.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Coding Tools Safety Module
+ * Path sandboxing and command denylist for secure tool execution
+ */
+export interface SafetyConfig {
+    /** Project root directory — all file operations are sandboxed here */
+    projectRoot: string;
+    /** Additional directories to allow (e.g., /tmp for scratch files) */
+    allowedPaths?: string[];
+    /** Extra commands to deny beyond the built-in denylist */
+    extraDeniedCommands?: string[];
+    /** Extra path patterns to deny (e.g., '.env', 'credentials') */
+    deniedPathPatterns?: RegExp[];
+}
+export declare function validatePath(filePath: string, config: SafetyConfig): {
+    safe: boolean;
+    reason?: string;
+};
+export declare function resolveSafePath(filePath: string, config: SafetyConfig): string;
+export declare function validateCommand(command: string, config: SafetyConfig): {
+    safe: boolean;
+    reason?: string;
+};
+export declare function configureSafety(config: SafetyConfig): void;
+export declare function getSafetyConfig(): SafetyConfig;
+//# sourceMappingURL=safety.d.ts.map

package/dist/tools/coding/safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safety.d.ts","sourceRoot":"","sources":["../../../src/tools/coding/safety.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,MAAM,WAAW,YAAY;IAC3B,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,0DAA0D;IAC1D,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAiDD,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,YAAY,GACnB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CA0BpC;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAE9E;AAMD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,YAAY,GACnB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAapC;AAQD,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE1D;AAED,wBAAgB,eAAe,IAAI,YAAY,CAK9C"}