icopilot 2.2.0

package/dist/commands/editor-cmd.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { config } from '../config.js';
+const WINDOWS_FALLBACK_EDITOR = 'code --wait';
+const UNIX_FALLBACK_EDITOR = 'vim';
+function detectEditor() {
+    const visual = process.env.VISUAL?.trim();
+    if (visual)
+        return visual;
+    const editor = process.env.EDITOR?.trim();
+    if (editor)
+        return editor;
+    return process.platform === 'win32' ? WINDOWS_FALLBACK_EDITOR : UNIX_FALLBACK_EDITOR;
+}
+function resolveEditorWorkspace() {
+    const candidate = config.cwd || process.cwd();
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+        return candidate;
+    }
+    return process.cwd();
+}
+function createTempFilePath(cwd) {
+    const nonce = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    return path.join(cwd, `.icopilot-editor-${nonce}.md`);
+}
+export async function openEditor() {
+    const cwd = resolveEditorWorkspace();
+    const editor = detectEditor();
+    const tempFilePath = createTempFilePath(cwd);
+    fs.writeFileSync(tempFilePath, '', 'utf8');
+    try {
+        const escapedPath = `"${tempFilePath.replace(/"/g, '\\"')}"`;
+        const result = spawnSync(`${editor} ${escapedPath}`, {
+            cwd,
+            shell: true,
+            stdio: 'inherit',
+        });
+        if (result.error)
+            throw result.error;
+        if (result.status !== 0 || result.signal)
+            return null;
+        const content = fs.readFileSync(tempFilePath, 'utf8').trim();
+        return content ? content : null;
+    }
+    finally {
+        fs.rmSync(tempFilePath, { force: true });
+    }
+}

package/dist/commands/env-cmd.js

@@ -0,0 +1,86 @@
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { theme } from '../ui/theme.js';
+const SECRET_MIN_LENGTH = 8;
+export function maskSecret(value) {
+    if (value.length < SECRET_MIN_LENGTH)
+        return '***';
+    return `${value.slice(0, 4)}***${value.slice(-2)}`;
+}
+export function envCommand(args) {
+    if (args[0] === '--check') {
+        return checkVar(args[1]);
+    }
+    if (args[0] === '--full') {
+        return formatEnvInfo('iCopilot environment', getFullEnvInfo());
+    }
+    return formatEnvInfo('Environment context', getDefaultEnvInfo());
+}
+function checkVar(name) {
+    if (!name)
+        return theme.warn('usage: /env --check <VAR>\n');
+    const value = process.env[name];
+    const source = value === undefined ? 'unset' : 'env';
+    const rendered = value === undefined ? theme.dim('(not set)') : renderValue(name, value);
+    return formatEnvInfo('Environment check', [{ key: name, value: rendered, source }]);
+}
+function getDefaultEnvInfo() {
+    const shellValue = process.env.SHELL || process.env.ComSpec;
+    const homeValue = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    const info = [
+        envEntry('GITHUB_TOKEN', process.env.GITHUB_TOKEN, 'env'),
+        envEntry('ICOPILOT_MODEL', process.env.ICOPILOT_MODEL, 'env'),
+        envEntry('ICOPILOT_THEME', process.env.ICOPILOT_THEME, 'env'),
+        envEntry('ICOPILOT_SANDBOX', process.env.ICOPILOT_SANDBOX, 'env'),
+        envEntry('ICOPILOT_DEBUG', process.env.ICOPILOT_DEBUG, 'env'),
+        envEntry('SHELL / ComSpec', shellValue, shellValue ? 'env' : 'unset'),
+        runtimeEntry('NODE_VERSION', process.version),
+        runtimeEntry('CWD', process.cwd()),
+        runtimeEntry('HOME', homeValue),
+    ];
+    const branch = gitBranch();
+    if (branch)
+        info.push({ key: 'Git branch', value: branch, source: 'git' });
+    return info;
+}
+function getFullEnvInfo() {
+    const matches = Object.entries(process.env)
+        .filter(([key]) => key.startsWith('ICOPILOT_'))
+        .sort(([left], [right]) => left.localeCompare(right));
+    if (matches.length === 0) {
+        return [{ key: 'ICOPILOT_*', value: theme.dim('(none set)'), source: 'env' }];
+    }
+    return matches.map(([key, value]) => envEntry(key, value, 'env'));
+}
+function envEntry(key, value, source) {
+    if (value === undefined) {
+        return { key, value: theme.dim('(not set)'), source: 'unset' };
+    }
+    return { key, value: renderValue(key, value), source };
+}
+function runtimeEntry(key, value) {
+    return { key, value, source: 'runtime' };
+}
+function renderValue(key, value) {
+    return isSecretKey(key) ? maskSecret(value) : value;
+}
+function isSecretKey(key) {
+    return /(TOKEN|SECRET|PASSWORD|KEY)$/i.test(key);
+}
+function gitBranch() {
+    try {
+        const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        return branch || null;
+    }
+    catch {
+        return null;
+    }
+}
+function formatEnvInfo(title, items) {
+    const lines = items.map(({ key, value, source }) => `  ${theme.hl(key)} ${theme.dim(`[${source}]`)} ${value}`);
+    return `${theme.brand(title)}\n${lines.join('\n')}\n`;
+}

package/dist/commands/explain-cmd.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+const DEFAULT_MAX_BYTES = 32_000;
+const DEFAULT_MAX_FILES = 25;
+const SKIP_NAMES = new Set(['node_modules', '.git', 'dist']);
+function readFilePreview(filePath, maxBytes) {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(Math.max(0, maxBytes));
+        const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+        return buffer.toString('utf8', 0, bytesRead);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function buildDirPreview(dirPath, maxFiles) {
+    const entries = fs
+        .readdirSync(dirPath, { withFileTypes: true })
+        .filter((entry) => !entry.name.startsWith('.') && !SKIP_NAMES.has(entry.name))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const immediate = entries.map((entry) => `- ${entry.name}${entry.isDirectory() ? '/' : ''}`);
+    const files = fg.sync('**/*', {
+        cwd: dirPath,
+        onlyFiles: true,
+        dot: false,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**'],
+        deep: 1,
+        unique: true,
+    });
+    const topFiles = files
+        .sort((a, b) => a.localeCompare(b))
+        .slice(0, Math.max(0, maxFiles))
+        .map((file) => `  - ${file}`);
+    return [`# Entries`, ...immediate, '', `# Top-level files`, ...topFiles].join('\n').trim();
+}
+export function buildExplain(target, cwd, opts = {}) {
+    const resolvedPath = path.resolve(cwd, target);
+    let stat;
+    try {
+        stat = fs.statSync(resolvedPath);
+    }
+    catch {
+        return {
+            kind: 'missing',
+            path: resolvedPath,
+            preview: '',
+            prompt: `Explain request for ${resolvedPath}: the path doesn't exist. Suggest what to check next.`,
+        };
+    }
+    if (stat.isFile()) {
+        const preview = readFilePreview(resolvedPath, opts.maxBytes ?? DEFAULT_MAX_BYTES);
+        return {
+            kind: 'file',
+            path: resolvedPath,
+            preview,
+            prompt: `Give a concise structured overview of this file (${resolvedPath}) in <= 200 words. ` +
+                `Cover purpose, key exports, and notable risks.\n\n${preview}`,
+        };
+    }
+    if (stat.isDirectory()) {
+        const preview = buildDirPreview(resolvedPath, opts.maxFiles ?? DEFAULT_MAX_FILES);
+        return {
+            kind: 'dir',
+            path: resolvedPath,
+            preview,
+            prompt: `Give an architectural summary of this folder (${resolvedPath}). ` +
+                `Explain the apparent responsibilities, important files, and likely extension points.\n\n${preview}`,
+        };
+    }
+    return {
+        kind: 'missing',
+        path: resolvedPath,
+        preview: '',
+        prompt: `Explain request for ${resolvedPath}: the path doesn't exist. Suggest what to check next.`,
+    };
+}

package/dist/commands/explain-shell-cmd.js

@@ -0,0 +1,22 @@
+export function explainShellCommand(command) {
+    const displayCommand = command || '(empty command)';
+    const prompt = [
+        'You are explaining a shell command to a developer.',
+        'Explain the command in plain English without assuming the user already knows the tool.',
+        'Do not invent flags or behavior that are not present.',
+        'Structure the answer as:',
+        '1. A short summary of the command purpose',
+        '2. A step-by-step breakdown of each subcommand, flag, argument, and shell operator',
+        '3. Likely effects on files, history, network, or system state',
+        '4. Risks, destructive behavior, or irreversible consequences',
+        '5. Safer alternatives or precautions when relevant',
+        'If the command is empty, incomplete, or ambiguous, say so clearly and explain what is missing.',
+        '',
+        `Command: ${displayCommand}`,
+        `Raw command text: ${JSON.stringify(command)}`,
+    ].join('\n');
+    return {
+        command,
+        prompt,
+    };
+}

package/dist/commands/explore-cmd.js

@@ -0,0 +1,231 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+const DEFAULT_MAX_DEPTH = 3;
+const DEFAULT_MAX_FILES = 200;
+const DEFAULT_IGNORES = new Set(['.git', 'node_modules', 'dist']);
+export function buildExplorePrompt(query, cwd) {
+    const resolvedCwd = path.resolve(cwd);
+    const context = [
+        `Workspace: ${resolvedCwd}`,
+        '',
+        'File tree (depth <= 3, capped at 200 files):',
+        gatherProjectContext(resolvedCwd, DEFAULT_MAX_DEPTH),
+        '',
+        'Project metadata:',
+        readProjectMetadata(resolvedCwd),
+        '',
+        'README snippet:',
+        readReadmeSnippet(resolvedCwd),
+        '',
+        'Git status:',
+        readGitStatus(resolvedCwd),
+    ].join('\n');
+    const prompt = [
+        'You are Explore, a lightweight codebase exploration agent.',
+        'Answer the user question using only the supplied project context.',
+        'Focus on architecture, likely file locations, relevant entry points, and practical next files to inspect.',
+        'When you mention files, use repo-relative paths.',
+        'If the context is incomplete, say what is missing instead of inventing details.',
+        '',
+        `User question: ${query.trim()}`,
+        '',
+        'Project context:',
+        context,
+    ].join('\n');
+    return { prompt, context };
+}
+export function gatherProjectContext(cwd, maxDepth = DEFAULT_MAX_DEPTH) {
+    const resolvedCwd = path.resolve(cwd);
+    if (!fs.existsSync(resolvedCwd) || !fs.statSync(resolvedCwd).isDirectory()) {
+        return '(workspace not found)';
+    }
+    const ignorePatterns = readGitignorePatterns(resolvedCwd);
+    const lines = ['.'];
+    let fileCount = 0;
+    let truncated = false;
+    const walk = (dirPath, depth, indent) => {
+        if (truncated || depth > maxDepth)
+            return;
+        const entries = fs
+            .readdirSync(dirPath, { withFileTypes: true })
+            .filter((entry) => !shouldIgnore(path.relative(resolvedCwd, path.join(dirPath, entry.name)), entry.isDirectory(), ignorePatterns))
+            .sort((left, right) => {
+            if (left.isDirectory() !== right.isDirectory()) {
+                return left.isDirectory() ? -1 : 1;
+            }
+            return left.name.localeCompare(right.name);
+        });
+        for (const entry of entries) {
+            if (truncated)
+                break;
+            const childPath = path.join(dirPath, entry.name);
+            const label = `${indent}${entry.name}${entry.isDirectory() ? '/' : ''}`;
+            lines.push(label);
+            if (entry.isDirectory()) {
+                if (depth < maxDepth) {
+                    walk(childPath, depth + 1, `${indent}  `);
+                }
+                continue;
+            }
+            fileCount += 1;
+            if (fileCount >= DEFAULT_MAX_FILES) {
+                truncated = true;
+            }
+        }
+    };
+    walk(resolvedCwd, 1, '  ');
+    if (truncated) {
+        lines.push(`  … truncated after ${DEFAULT_MAX_FILES} files`);
+    }
+    return lines.join('\n');
+}
+export function exploreCommand(args, cwd) {
+    const query = args.join(' ').trim();
+    if (!query) {
+        return 'usage: /explore <question>\n';
+    }
+    return buildExplorePrompt(query, cwd).prompt;
+}
+function readProjectMetadata(cwd) {
+    const sections = [];
+    const packageJsonPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        sections.push(formatPackageJson(packageJsonPath));
+    }
+    const cargoTomlPath = path.join(cwd, 'Cargo.toml');
+    if (fs.existsSync(cargoTomlPath)) {
+        sections.push(formatSnippet('Cargo.toml', cargoTomlPath, 20));
+    }
+    const goModPath = path.join(cwd, 'go.mod');
+    if (fs.existsSync(goModPath)) {
+        sections.push(formatSnippet('go.mod', goModPath, 20));
+    }
+    if (!sections.length) {
+        return '(no package.json, Cargo.toml, or go.mod found)';
+    }
+    return sections.join('\n\n');
+}
+function formatPackageJson(packageJsonPath) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const scripts = Object.keys(raw.scripts ?? {}).sort((a, b) => a.localeCompare(b));
+        const deps = Object.keys(raw.dependencies ?? {}).sort((a, b) => a.localeCompare(b));
+        const devDeps = Object.keys(raw.devDependencies ?? {}).sort((a, b) => a.localeCompare(b));
+        return [
+            'package.json:',
+            `  name: ${raw.name ?? '(unknown)'}`,
+            `  type: ${raw.type ?? '(unspecified)'}`,
+            `  scripts: ${scripts.length ? scripts.join(', ') : '(none)'}`,
+            `  dependencies (${deps.length}): ${deps.slice(0, 12).join(', ') || '(none)'}`,
+            `  devDependencies (${devDeps.length}): ${devDeps.slice(0, 12).join(', ') || '(none)'}`,
+        ].join('\n');
+    }
+    catch {
+        return 'package.json:\n  (failed to parse)';
+    }
+}
+function readReadmeSnippet(cwd) {
+    const readmeNames = ['README.md', 'README', 'readme.md', 'readme'];
+    const readmePath = readmeNames
+        .map((name) => path.join(cwd, name))
+        .find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+    if (!readmePath) {
+        return '(no README found)';
+    }
+    try {
+        const snippet = fs.readFileSync(readmePath, 'utf8').slice(0, 1_500).trim();
+        return snippet || '(README is empty)';
+    }
+    catch {
+        return '(failed to read README)';
+    }
+}
+function readGitStatus(cwd) {
+    try {
+        const output = execFileSync('git', ['status', '--short', '--branch'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+        return output || '(clean working tree)';
+    }
+    catch {
+        return '(not a git repository or git status unavailable)';
+    }
+}
+function formatSnippet(label, filePath, maxLines) {
+    try {
+        const lines = fs
+            .readFileSync(filePath, 'utf8')
+            .split(/\r?\n/)
+            .slice(0, maxLines)
+            .join('\n')
+            .trim();
+        return `${label}:\n${lines || '(empty)'}`;
+    }
+    catch {
+        return `${label}:\n(failed to read)`;
+    }
+}
+function readGitignorePatterns(cwd) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        return [];
+    }
+    try {
+        return fs
+            .readFileSync(gitignorePath, 'utf8')
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith('#') && !line.startsWith('!'));
+    }
+    catch {
+        return [];
+    }
+}
+function shouldIgnore(relativePath, isDirectory, patterns) {
+    if (!relativePath || relativePath.startsWith('..')) {
+        return false;
+    }
+    const normalized = normalizeSlashes(relativePath);
+    const segments = normalized.split('/');
+    if (segments.some((segment) => DEFAULT_IGNORES.has(segment))) {
+        return true;
+    }
+    return patterns.some((pattern) => matchesGitignorePattern(normalized, segments, isDirectory, pattern));
+}
+function matchesGitignorePattern(normalizedPath, segments, isDirectory, pattern) {
+    const normalizedPattern = normalizeSlashes(pattern).replace(/^\/+/, '');
+    const directoryOnly = normalizedPattern.endsWith('/');
+    const barePattern = normalizedPattern.replace(/\/+$/, '');
+    if (directoryOnly && !isDirectory && barePattern === normalizedPath) {
+        return false;
+    }
+    if (!barePattern) {
+        return false;
+    }
+    if (!hasGlob(barePattern) && !barePattern.includes('/')) {
+        return segments.includes(barePattern);
+    }
+    if (!hasGlob(barePattern)) {
+        return normalizedPath === barePattern || normalizedPath.startsWith(`${barePattern}/`);
+    }
+    const regex = globToRegExp(barePattern);
+    return regex.test(normalizedPath);
+}
+function hasGlob(value) {
+    return /[*?[\]]/.test(value);
+}
+function globToRegExp(pattern) {
+    const source = pattern
+        .replace(/[|\\{}()[\]^$+.]/g, '\\$&')
+        .replace(/\*\*/g, '::DOUBLE_STAR::')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/::DOUBLE_STAR::/g, '.*');
+    return new RegExp(`^${source}(?:/.*)?$`);
+}
+function normalizeSlashes(value) {
+    return value.split(path.sep).join('/');
+}

package/dist/commands/feedback-cmd.js

@@ -0,0 +1,98 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { theme } from '../ui/theme.js';
+export function feedbackPath() {
+    const configured = process.env.ICOPILOT_FEEDBACK_PATH || path.join(os.homedir(), '.icopilot', 'feedback.json');
+    if (configured === '~')
+        return os.homedir();
+    if (/^~[\\/]/.test(configured))
+        return path.join(os.homedir(), configured.slice(2));
+    return path.resolve(configured);
+}
+export function submitFeedback(type, text, options = {}) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        throw new Error('feedback text is required');
+    }
+    const entries = loadFeedback();
+    const repo = options.repo ?? getGitHubRepoSlug(options.cwd);
+    entries.push({
+        type,
+        text: trimmed,
+        timestamp: new Date().toISOString(),
+        cwd: options.cwd,
+        repo: repo ?? undefined,
+    });
+    saveFeedback(entries);
+    const lines = [theme.ok('Thank you for your feedback!')];
+    if (repo) {
+        lines.push(theme.dim(`GitHub issues: ${buildGitHubIssuesUrl(repo)}`));
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function loadFeedback() {
+    const file = feedbackPath();
+    if (!fs.existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.flatMap((entry) => {
+            if (!entry || typeof entry !== 'object')
+                return [];
+            const record = entry;
+            if ((record.type !== 'bug' && record.type !== 'feature' && record.type !== 'praise') ||
+                typeof record.text !== 'string' ||
+                typeof record.timestamp !== 'string') {
+                return [];
+            }
+            return [
+                {
+                    type: record.type,
+                    text: record.text,
+                    timestamp: record.timestamp,
+                    cwd: typeof record.cwd === 'string' ? record.cwd : undefined,
+                    repo: typeof record.repo === 'string' ? record.repo : undefined,
+                },
+            ];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function saveFeedback(entries) {
+    const file = feedbackPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(entries, null, 2)}\n`, 'utf8');
+}
+export function buildGitHubIssuesUrl(repo) {
+    return `https://github.com/${repo}/issues/new`;
+}
+export function getGitHubRepoSlug(cwd = process.cwd()) {
+    try {
+        const remote = execFileSync('git', ['remote', 'get-url', 'origin'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }).trim();
+        const match = remote.match(/github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?$/i);
+        return match?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function openGitHubIssues(repo) {
+    const url = buildGitHubIssuesUrl(repo);
+    const result = process.platform === 'win32'
+        ? spawnSync('cmd', ['/c', 'start', '', url], { windowsHide: true })
+        : process.platform === 'darwin'
+            ? spawnSync('open', [url], { windowsHide: true })
+            : spawnSync('xdg-open', [url], { windowsHide: true });
+    return result.status === 0;
+}

package/dist/commands/fix-cmd.js

@@ -0,0 +1,17 @@
+export function buildFixPrompt(errorText) {
+    const error = errorText;
+    const trimmedError = errorText.trim();
+    const quotedError = trimmedError.length > 0 ? trimmedError : '[no error text provided]';
+    return {
+        error,
+        prompt: [
+            'You are helping diagnose a CLI or developer tooling error.',
+            'Identify the error shown below, explain the most likely root cause, and suggest 2-3 fixes ranked by likelihood.',
+            'For each fix, include the exact commands to run and a short note about what the command does.',
+            'If the error text is ambiguous, say so briefly and still provide the most plausible fixes first.',
+            '',
+            'Error text:',
+            quotedError,
+        ].join('\n'),
+    };
+}

package/dist/commands/generate-cmd.js

@@ -0,0 +1,38 @@
+export function detectShell() {
+    const candidates = [
+        process.env.SHELL,
+        process.env.ICOPILOT_SHELL,
+        process.env.TERM_PROGRAM,
+        process.env.ComSpec,
+    ]
+        .filter((value) => typeof value === 'string' && value.trim().length > 0)
+        .map((value) => value.toLowerCase());
+    for (const candidate of candidates) {
+        if (candidate.includes('pwsh') || candidate.includes('powershell'))
+            return 'pwsh';
+        if (candidate.includes('zsh'))
+            return 'zsh';
+        if (candidate.includes('fish'))
+            return 'fish';
+        if (candidate.includes('bash'))
+            return 'bash';
+    }
+    return 'bash';
+}
+export function buildGeneratePrompt(goal, shell = detectShell()) {
+    const prompt = [
+        `You are generating a complete, runnable ${shell} script for a developer.`,
+        'Return only the script text.',
+        'Use the requested shell dialect consistently.',
+        'Include helpful comments that explain the major steps.',
+        'Handle errors safely: enable set -e immediately when the shell supports it, and use the closest equivalent for other shells.',
+        'Make the script executable as written with sensible defaults and clear variable names.',
+        '',
+        `Goal: ${goal}`,
+    ].join('\n');
+    return {
+        goal,
+        shell,
+        prompt,
+    };
+}