icopilot 2.2.0

package/dist/commands/schedule-cmd.js

@@ -0,0 +1,109 @@
+import { randomUUID } from 'node:crypto';
+const scheduled = new Map();
+let currentRunner = null;
+export function setScheduleRunner(runner) {
+    currentRunner = runner;
+}
+export function scheduleRecurring(interval, prompt) {
+    return scheduleTask('recurring', interval, prompt);
+}
+export function scheduleOnce(delay, prompt) {
+    return scheduleTask('once', delay, prompt);
+}
+export function listScheduled() {
+    return [...scheduled.values()]
+        .map((entry) => ({ ...entry.task, nextRun: new Date(entry.task.nextRun) }))
+        .sort((left, right) => left.nextRun.getTime() - right.nextRun.getTime());
+}
+export function cancelSchedule(id) {
+    const entry = scheduled.get(id);
+    if (!entry)
+        return false;
+    clearTimer(entry.task.type, entry.timer);
+    scheduled.delete(id);
+    return true;
+}
+export function resetScheduledTasks() {
+    for (const entry of scheduled.values()) {
+        clearTimer(entry.task.type, entry.timer);
+    }
+    scheduled.clear();
+}
+export function parseInterval(input) {
+    const trimmed = input.trim().toLowerCase();
+    if (!trimmed)
+        throw new Error('interval is required');
+    const pattern = /(\d+)([hms])/g;
+    let total = 0;
+    let consumed = 0;
+    let match;
+    while ((match = pattern.exec(trimmed)) !== null) {
+        const value = Number(match[1]);
+        const unit = match[2];
+        consumed += match[0].length;
+        total += value * unitToMs(unit);
+    }
+    if (consumed !== trimmed.length || total <= 0) {
+        throw new Error(`invalid interval: ${input}`);
+    }
+    return total;
+}
+function scheduleTask(type, intervalSource, prompt) {
+    const normalizedPrompt = prompt.trim();
+    if (!normalizedPrompt)
+        throw new Error('prompt is required');
+    if (!currentRunner)
+        throw new Error('scheduled prompts are not available in this session');
+    const interval = parseInterval(intervalSource);
+    const task = {
+        id: randomUUID(),
+        type,
+        interval,
+        prompt: normalizedPrompt,
+        nextRun: new Date(Date.now() + interval),
+    };
+    const run = currentRunner;
+    if (type === 'recurring') {
+        const timer = setInterval(() => {
+            void fireTask(task.id);
+        }, interval);
+        scheduled.set(task.id, { task, timer, run });
+    }
+    else {
+        const timer = setTimeout(() => {
+            void fireTask(task.id);
+        }, interval);
+        scheduled.set(task.id, { task, timer, run });
+    }
+    return { ...task, nextRun: new Date(task.nextRun) };
+}
+async function fireTask(id) {
+    const entry = scheduled.get(id);
+    if (!entry)
+        return;
+    if (entry.task.type === 'once') {
+        scheduled.delete(id);
+    }
+    else {
+        entry.task.nextRun = new Date(Date.now() + entry.task.interval);
+    }
+    await entry.run(entry.task.prompt);
+}
+function clearTimer(type, timer) {
+    if (type === 'recurring')
+        clearInterval(timer);
+    else
+        clearTimeout(timer);
+}
+function unitToMs(unit) {
+    switch (unit) {
+        case 'h':
+            return 60 * 60 * 1000;
+        case 'm':
+            return 60 * 1000;
+        case 's':
+            return 1000;
+        default:
+            throw new Error(`unsupported interval unit: ${unit}`);
+    }
+}

package/dist/commands/search-cmd.js

@@ -0,0 +1,47 @@
+import { searchIndex } from '../index/store.js';
+import { theme } from '../ui/theme.js';
+const DEFAULT_LIMIT = 6;
+const PREVIEW_LIMIT = 180;
+export async function searchCommand(args, cwd) {
+    const query = args.join(' ').trim();
+    if (!query) {
+        return theme.warn('usage: /search <query>\n');
+    }
+    try {
+        const hits = await searchIndex(cwd, query, DEFAULT_LIMIT);
+        if (!hits.length) {
+            return theme.dim('No matches found.\n');
+        }
+        return formatResults(query, hits);
+    }
+    catch (error) {
+        if (isMissingIndexError(error)) {
+            return theme.warn('No index found. Run `/index build` first.\n');
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return theme.err(`search failed: ${message}\n`);
+    }
+}
+function formatResults(query, hits) {
+    const lines = [`${theme.brand('Search results')} ${theme.dim(`for "${query}"`)}`, ''];
+    for (const hit of hits) {
+        lines.push(`${theme.hl(hit.file)} ${theme.dim(`(score ${hit.score.toFixed(3)})`)}`);
+        lines.push(`  ${formatPreview(hit.text)}`);
+        lines.push('');
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+function formatPreview(text) {
+    const normalized = text.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= PREVIEW_LIMIT)
+        return normalized;
+    return `${normalized.slice(0, PREVIEW_LIMIT - 3)}...`;
+}
+function isMissingIndexError(error) {
+    if (typeof error !== 'object' || error === null) {
+        return false;
+    }
+    const code = 'code' in error ? String(error.code ?? '') : '';
+    const message = 'message' in error ? String(error.message ?? '') : '';
+    return code === 'ENOENT' || /no index found|index not found/i.test(message);
+}

package/dist/commands/security-cmd.js

@@ -0,0 +1,156 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { theme } from '../ui/theme.js';
+export const SCANNABLE_EXTENSIONS = [
+    '.ts',
+    '.js',
+    '.py',
+    '.env',
+    '.yml',
+    '.yaml',
+    '.json',
+    '.toml',
+    '.cfg',
+    '.ini',
+    '.conf',
+    '.sh',
+    '.bash',
+    '.rb',
+    '.go',
+    '.java',
+    '.cs',
+    '.php',
+];
+const MAX_FILES = 1000;
+const MAX_LINES = 500;
+const SECURITY_PATTERNS = [
+    {
+        name: 'AWS key',
+        regex: /AKIA[0-9A-Z]{16}/,
+        severity: 'high',
+        description: 'Possible AWS access key exposed in source.',
+    },
+    {
+        name: 'Private key',
+        regex: /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----/,
+        severity: 'high',
+        description: 'Private key material should never be committed.',
+    },
+    {
+        name: 'GitHub token',
+        regex: /gh[pousr]_[A-Za-z0-9_]{36,}/,
+        severity: 'high',
+        description: 'Possible GitHub token found in a tracked file.',
+    },
+    {
+        name: 'Password in code',
+        regex: /(?:password|passwd|pwd)\s*[:=]\s*['"][^'"]{4,}/i,
+        severity: 'medium',
+        description: 'Literal password-like value detected in code or config.',
+    },
+    {
+        name: 'API key',
+        regex: /(?:api[_-]?key|apikey)\s*[:=]\s*['"][A-Za-z0-9]{20,}/i,
+        severity: 'medium',
+        description: 'API key assignment detected; consider environment-based secrets.',
+    },
+    {
+        name: 'Generic secret',
+        regex: /(?:secret|token)\s*[:=]\s*['"][A-Za-z0-9+/=]{20,}/i,
+        severity: 'low',
+        description: 'Secret or token-like literal detected.',
+    },
+];
+function isEnvFile(filePath) {
+    const baseName = path.basename(filePath).toLowerCase();
+    return baseName === '.env' || baseName.startsWith('.env.');
+}
+function isScannableFile(filePath) {
+    if (isEnvFile(filePath))
+        return true;
+    return SCANNABLE_EXTENSIONS.includes(path.extname(filePath).toLowerCase());
+}
+function readLines(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8').split(/\r?\n/).slice(0, MAX_LINES);
+    }
+    catch {
+        return [];
+    }
+}
+function listCandidateFiles(cwd) {
+    return fg
+        .sync('**/*', {
+        cwd,
+        absolute: true,
+        onlyFiles: true,
+        dot: true,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**'],
+    })
+        .filter(isScannableFile)
+        .slice(0, MAX_FILES);
+}
+export function scanFilesForSecrets(cwd, relativePaths) {
+    if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory())
+        return [];
+    const findings = [];
+    for (const relativePath of relativePaths) {
+        const normalizedRelativePath = path.normalize(relativePath);
+        const filePath = path.join(cwd, normalizedRelativePath);
+        if (!isScannableFile(filePath) || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+            continue;
+        }
+        const lines = readLines(filePath);
+        lines.forEach((lineText, index) => {
+            for (const pattern of SECURITY_PATTERNS) {
+                if (pattern.regex.test(lineText)) {
+                    findings.push({
+                        file: normalizedRelativePath,
+                        line: index + 1,
+                        pattern: pattern.name,
+                        severity: pattern.severity,
+                        description: pattern.description,
+                    });
+                }
+            }
+        });
+    }
+    return findings;
+}
+export function scanForSecrets(cwd) {
+    return scanFilesForSecrets(cwd, listCandidateFiles(cwd).map((filePath) => path.relative(cwd, filePath)));
+}
+function severityColor(severity) {
+    switch (severity) {
+        case 'high':
+            return theme.err;
+        case 'medium':
+            return theme.warn;
+        case 'low':
+            return theme.dim;
+    }
+}
+function formatGroup(severity, findings) {
+    if (findings.length === 0)
+        return '';
+    const color = severityColor(severity);
+    const title = color(`${severity.toUpperCase()} (${findings.length})`);
+    const lines = findings.map((finding) => `  ${color(finding.file)}:${finding.line}  ${finding.pattern}  ${theme.dim(`- ${finding.description}`)}`);
+    return `${title}\n${lines.join('\n')}`;
+}
+export function securityCommand(cwd) {
+    const findings = scanForSecrets(cwd);
+    if (findings.length === 0) {
+        return `${theme.ok('No obvious security issues detected.')}\n${theme.dim('Scanned common secret and credential patterns in source files.')}\n`;
+    }
+    const grouped = {
+        high: findings.filter((finding) => finding.severity === 'high'),
+        medium: findings.filter((finding) => finding.severity === 'medium'),
+        low: findings.filter((finding) => finding.severity === 'low'),
+    };
+    const sections = ['high', 'medium', 'low']
+        .map((severity) => formatGroup(severity, grouped[severity]))
+        .filter(Boolean);
+    return `${theme.brand('Security findings')}\n${sections.join('\n\n')}\n`;
+}

package/dist/commands/settings-cmd.js

@@ -0,0 +1,238 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config, getDefaultConfig, rcFilePath, } from '../config.js';
+import { theme } from '../ui/theme.js';
+const BOOLEAN_TRUE = /^(1|true|yes|on)$/i;
+const BOOLEAN_FALSE = /^(0|false|no|off)$/i;
+const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+const THEMES = ['auto', 'light', 'dark', 'none'];
+const REASONING_LEVELS = ['low', 'medium', 'high', 'max'];
+const KEYBINDING_MODES = ['default', 'vi', 'emacs'];
+const SETTING_DEFINITIONS = [
+    textSetting('model', 'defaultModel', ['defaultModel']),
+    enumSetting('theme', 'theme', THEMES),
+    enumSetting('editFormat', 'editFormat', ['whole', 'diff'], ['edit-format']),
+    booleanSetting('autoLint', 'autoLint', ['auto-lint']),
+    booleanSetting('autoTest', 'autoTest', ['auto-test']),
+    optionalEnumSetting('reasoningEffort', 'reasoningEffort', REASONING_LEVELS, [
+        'reasoning',
+        'reasoning-effort',
+    ]),
+    optionalNumberSetting('thinkTokens', 'thinkTokens', ['think-tokens']),
+    booleanSetting('sandbox', 'sandbox'),
+    numberSetting('contextWindow', 'contextWindow', ['context-window']),
+    numberSetting('contextWarn', 'contextWarn', ['context-warn']),
+    booleanSetting('autoCompact', 'autoCompact', ['auto-compact']),
+    numberSetting('autoCompactThreshold', 'autoCompactThreshold', ['auto-compact-threshold']),
+    booleanSetting('verbose', 'verbose'),
+    enumSetting('logLevel', 'logLevel', LOG_LEVELS, ['log-level']),
+    textSetting('sessionDir', 'sessionDir', ['session-dir']),
+    textSetting('endpoint', 'endpoint'),
+    optionalTextSetting('policyPath', 'policyPath', ['policy', 'policy-path']),
+    booleanSetting('jsonOutput', 'jsonOutput', ['json', 'json-output']),
+    booleanSetting('quiet', 'quiet'),
+    booleanSetting('autoApprove', 'autoApprove', ['auto-approve']),
+    {
+        key: 'keybindings',
+        configKey: 'keybindings',
+        aliases: ['keybinding'],
+        parse: (value) => {
+            const mode = value.trim().toLowerCase();
+            if (!KEYBINDING_MODES.includes(mode)) {
+                throw new Error(`keybindings must be one of: ${KEYBINDING_MODES.join(', ')}`);
+            }
+            return { mode };
+        },
+        format: (value) => {
+            if (!value || typeof value !== 'object' || !('mode' in value))
+                return 'default';
+            return value.mode;
+        },
+    },
+];
+export function showSettings() {
+    const defaults = getDefaultConfig();
+    const persisted = loadRcData();
+    const keyWidth = Math.max(...SETTING_DEFINITIONS.map((entry) => entry.key.length), 'setting'.length) + 2;
+    const valueWidth = 18;
+    const defaultWidth = 18;
+    const lines = [
+        theme.brand('Settings'),
+        `  ${pad('setting', keyWidth)}${pad('value', valueWidth)}${pad('default', defaultWidth)}persisted`,
+        `  ${theme.dim('-'.repeat(keyWidth + valueWidth + defaultWidth + 'persisted'.length))}`,
+    ];
+    for (const definition of SETTING_DEFINITIONS) {
+        const current = formatValue(definition, config[definition.configKey]);
+        const fallback = formatValue(definition, defaults[definition.configKey]);
+        const stored = [definition.key, definition.configKey, ...(definition.aliases ?? [])].some((candidate) => Object.prototype.hasOwnProperty.call(persisted, candidate));
+        lines.push(`  ${pad(definition.key, keyWidth)}${pad(current, valueWidth)}${pad(fallback, defaultWidth)}${stored ? theme.ok('yes') : theme.dim('no')}`);
+    }
+    lines.push('', `  rc file: ${theme.dim(rcFilePath())}`, '');
+    return lines.join('\n');
+}
+export function setSetting(key, value) {
+    const definition = resolveSetting(key);
+    const trimmedValue = value.trim();
+    if (!trimmedValue) {
+        throw new Error(`value is required for setting: ${definition.key}`);
+    }
+    const parsed = definition.parse(trimmedValue);
+    applyRuntimeSetting(definition, parsed);
+    const rcData = loadRcData();
+    rcData[definition.key] = toPersistedValue(parsed);
+    writeRcData(rcData);
+    return theme.ok(`✔ setting ${definition.key} → ${formatValue(definition, parsed)}\n`);
+}
+export function resetSetting(key) {
+    const definition = resolveSetting(key);
+    const defaults = getDefaultConfig();
+    applyRuntimeSetting(definition, defaults[definition.configKey]);
+    const rcData = loadRcData();
+    delete rcData[definition.key];
+    writeRcData(rcData);
+    return theme.ok(`✔ reset ${definition.key} → ${formatValue(definition, defaults[definition.configKey])}\n`);
+}
+export function isModelSettingKey(key) {
+    return resolveSetting(key).key === 'model';
+}
+function resolveSetting(key) {
+    const normalized = key.trim().toLowerCase();
+    const definition = SETTING_DEFINITIONS.find((entry) => [entry.key, ...(entry.aliases ?? [])].some((candidate) => candidate.toLowerCase() === normalized));
+    if (!definition) {
+        throw new Error(`unsupported setting: ${key}`);
+    }
+    return definition;
+}
+function loadRcData() {
+    const file = rcFilePath();
+    if (!fs.existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? { ...parsed }
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeRcData(data) {
+    const file = rcFilePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const entries = Object.entries(data).filter(([, value]) => value !== undefined);
+    const sorted = Object.fromEntries(entries.sort(([left], [right]) => left.localeCompare(right)));
+    fs.writeFileSync(file, `${JSON.stringify(sorted, null, 2)}\n`, 'utf8');
+}
+function applyRuntimeSetting(definition, value) {
+    const mutableConfig = config;
+    mutableConfig[definition.configKey] = value;
+    if (definition.key === 'sandbox') {
+        if (value)
+            process.env.ICOPILOT_SANDBOX = '1';
+        else
+            delete process.env.ICOPILOT_SANDBOX;
+    }
+}
+function formatValue(definition, value) {
+    if (value === undefined || value === null || value === '')
+        return theme.dim('(default)');
+    if (definition.format)
+        return definition.format(value);
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    return String(value);
+}
+function toPersistedValue(value) {
+    return value === undefined ? undefined : value;
+}
+function parseBoolean(value) {
+    if (BOOLEAN_TRUE.test(value))
+        return true;
+    if (BOOLEAN_FALSE.test(value))
+        return false;
+    throw new Error(`invalid boolean: ${value}`);
+}
+function pad(value, width) {
+    return `${value}`.padEnd(width);
+}
+function textSetting(key, configKey, aliases = []) {
+    return {
+        key,
+        configKey,
+        aliases,
+        parse: (value) => value,
+    };
+}
+function optionalTextSetting(key, configKey, aliases = []) {
+    return {
+        key,
+        configKey,
+        aliases,
+        parse: (value) => (/^(default|none|off)$/i.test(value) ? undefined : value),
+    };
+}
+function booleanSetting(key, configKey, aliases = []) {
+    return {
+        key,
+        configKey,
+        aliases,
+        parse: parseBoolean,
+    };
+}
+function enumSetting(key, configKey, allowed, aliases = []) {
+    return {
+        key,
+        configKey,
+        aliases,
+        parse: (value) => {
+            const normalized = value.trim().toLowerCase();
+            const mapped = normalized === 'no-color' ? 'none' : normalized;
+            const match = allowed.find((entry) => entry === mapped);
+            if (!match) {
+                throw new Error(`invalid ${key}: ${value}`);
+            }
+            return match;
+        },
+    };
+}
+function optionalEnumSetting(key, configKey, allowed, aliases = []) {
+    return {
+        key,
+        configKey,
+        aliases,
+        parse: (value) => {
+            if (/^(default|none|off)$/i.test(value))
+                return undefined;
+            return enumSetting(key, configKey, allowed, aliases).parse(value);
+        },
+        format: (value) => (value === undefined ? theme.dim('(default)') : String(value)),
+    };
+}
+function numberSetting(key, configKey, aliases = []) {
+    return {
+        key,
+        configKey,
+        aliases,
+        parse: (value) => {
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed)) {
+                throw new Error(`invalid number: ${value}`);
+            }
+            return parsed;
+        },
+    };
+}
+function optionalNumberSetting(key, configKey, aliases = []) {
+    return {
+        key,
+        configKey,
+        aliases,
+        parse: (value) => {
+            if (/^(default|none|off)$/i.test(value))
+                return undefined;
+            return numberSetting(key, configKey, aliases).parse(value);
+        },
+        format: (value) => (value === undefined ? theme.dim('(default)') : String(value)),
+    };
+}