icopilot 2.2.0

package/dist/snippets/store.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const NAME_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
+export function snippetsDir() {
+    return process.env.ICOPILOT_SNIPPETS_DIR || path.join(os.homedir(), '.icopilot', 'snippets');
+}
+export function listSnippets() {
+    const dir = snippetsDir();
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+        .map((entry) => readSnippet(path.basename(entry.name, '.md')))
+        .filter((snippet) => snippet !== null)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function saveSnippet(name, body) {
+    assertValidName(name);
+    const dir = snippetsDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = snippetPath(name);
+    fs.writeFileSync(file, body, 'utf8');
+    return snippetFromFile(name, file);
+}
+export function readSnippet(name) {
+    assertValidName(name);
+    const file = snippetPath(name);
+    if (!fs.existsSync(file))
+        return null;
+    return snippetFromFile(name, file);
+}
+export function deleteSnippet(name) {
+    assertValidName(name);
+    const file = snippetPath(name);
+    if (!fs.existsSync(file))
+        return false;
+    fs.unlinkSync(file);
+    return true;
+}
+export function expandSnippet(body, vars) {
+    return body.replace(/\{\{([a-zA-Z0-9_-]+)\}\}/g, (match, key) => vars[key] ?? match);
+}
+function assertValidName(name) {
+    if (!NAME_RE.test(name)) {
+        throw new Error('Invalid snippet name. Use 1-64 letters, numbers, underscores, or dashes; start with a letter or number.');
+    }
+}
+function snippetPath(name) {
+    return path.join(snippetsDir(), `${name}.md`);
+}
+function snippetFromFile(name, file) {
+    const stat = fs.statSync(file);
+    return {
+        name,
+        body: fs.readFileSync(file, 'utf8'),
+        updatedAt: stat.mtime.toISOString(),
+    };
+}

package/dist/spaces/space-config.js

@@ -0,0 +1,156 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const DEFAULT_SPACE_CONFIG = {
+    tools: [],
+    contextFiles: [],
+};
+export const DEFAULT_SPACE_CONFIG_TEMPLATE = serializeSpaceConfig(DEFAULT_SPACE_CONFIG);
+export function loadSpaceConfig(dir) {
+    const file = configPath(dir);
+    if (!fs.existsSync(file))
+        return cloneSpaceConfig(DEFAULT_SPACE_CONFIG);
+    try {
+        const parsed = parseSpaceConfig(fs.readFileSync(file, 'utf8'));
+        return {
+            model: parsed.model,
+            systemPrompt: parsed.systemPrompt,
+            tools: parsed.tools ?? [],
+            contextFiles: parsed.contextFiles ?? [],
+            maxTokens: parsed.maxTokens,
+        };
+    }
+    catch {
+        return cloneSpaceConfig(DEFAULT_SPACE_CONFIG);
+    }
+}
+export function saveSpaceConfig(dir, config) {
+    const file = configPath(dir);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, serializeSpaceConfig(config), 'utf8');
+}
+export function serializeSpaceConfig(config) {
+    const lines = [
+        `model: ${formatScalar(config.model)}`,
+        `systemPrompt: ${formatScalar(config.systemPrompt)}`,
+        ...formatArray('tools', config.tools),
+        ...formatArray('contextFiles', config.contextFiles),
+        `maxTokens: ${typeof config.maxTokens === 'number' ? String(config.maxTokens) : ''}`,
+    ];
+    return `${lines.join('\n')}\n`;
+}
+function configPath(dir) {
+    return path.join(dir, '.icopilot', 'space.yaml');
+}
+function cloneSpaceConfig(config) {
+    return {
+        model: config.model,
+        systemPrompt: config.systemPrompt,
+        tools: [...(config.tools ?? [])],
+        contextFiles: [...(config.contextFiles ?? [])],
+        maxTokens: config.maxTokens,
+    };
+}
+function parseSpaceConfig(source) {
+    const result = cloneSpaceConfig(DEFAULT_SPACE_CONFIG);
+    const lines = source.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const rawLine = lines[index];
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const match = /^([A-Za-z][A-Za-z0-9]*):\s*(.*)$/.exec(line);
+        if (!match)
+            continue;
+        const [, key, value] = match;
+        switch (key) {
+            case 'model':
+                result.model = parseString(value);
+                break;
+            case 'systemPrompt':
+                result.systemPrompt = parseString(value);
+                break;
+            case 'maxTokens':
+                result.maxTokens = parseNumber(value);
+                break;
+            case 'tools':
+            case 'contextFiles': {
+                const { items, nextIndex } = parseArray(lines, index, value);
+                result[key] = items;
+                index = nextIndex;
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return result;
+}
+function parseArray(lines, index, inlineValue) {
+    const trimmed = inlineValue.trim();
+    if (!trimmed) {
+        const items = [];
+        let nextIndex = index;
+        for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+            const line = lines[cursor];
+            if (!line.trim() || line.trim().startsWith('#')) {
+                nextIndex = cursor;
+                continue;
+            }
+            if (!/^\s+-\s+/.test(line))
+                break;
+            items.push(parseItem(line.replace(/^\s+-\s+/, '')));
+            nextIndex = cursor;
+        }
+        return { items, nextIndex };
+    }
+    if (trimmed === '[]')
+        return { items: [], nextIndex: index };
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        const inner = trimmed.slice(1, -1).trim();
+        if (!inner)
+            return { items: [], nextIndex: index };
+        return {
+            items: inner
+                .split(',')
+                .map((part) => parseItem(part))
+                .filter((part) => part.length > 0),
+            nextIndex: index,
+        };
+    }
+    return { items: [parseItem(trimmed)], nextIndex: index };
+}
+function parseItem(value) {
+    return parseString(value) ?? '';
+}
+function parseString(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === 'null')
+        return undefined;
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed.slice(1, -1);
+        }
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        return trimmed.slice(1, -1).replace(/''/g, "'");
+    }
+    return trimmed;
+}
+function parseNumber(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function formatScalar(value) {
+    return typeof value === 'string' ? JSON.stringify(value) : '';
+}
+function formatArray(name, values) {
+    if (!values || values.length === 0)
+        return [`${name}: []`];
+    return [name + ':', ...values.map((value) => `  - ${JSON.stringify(value)}`)];
+}

package/dist/spaces/space.js

@@ -0,0 +1,220 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { config } from '../config.js';
+import { DEFAULT_SPACE_CONFIG, loadSpaceConfig, saveSpaceConfig } from './space-config.js';
+const SPACES_ENV = 'ICOPILOT_SPACES_DIR';
+const CURRENT_FILE = 'current.txt';
+export class SpaceManager {
+    cwdProvider;
+    storeDir;
+    constructor(cwdProvider = () => config.cwd, storeDir = spacesDir()) {
+        this.cwdProvider = cwdProvider;
+        this.storeDir = storeDir;
+    }
+    loadSpace(name) {
+        const file = this.spaceFile(name);
+        if (!fs.existsSync(file)) {
+            throw new Error(`space not found: ${name}`);
+        }
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return normalizeSpace(parsed, name);
+    }
+    createSpace(name, rootPath) {
+        const normalizedName = validateName(name);
+        const normalizedRootPath = path.resolve(rootPath);
+        const file = this.spaceFile(normalizedName);
+        if (fs.existsSync(file)) {
+            throw new Error(`space already exists: ${normalizedName}`);
+        }
+        if (!fs.existsSync(normalizedRootPath) || !fs.statSync(normalizedRootPath).isDirectory()) {
+            throw new Error(`space root is not a directory: ${normalizedRootPath}`);
+        }
+        const space = {
+            name: normalizedName,
+            rootPath: normalizedRootPath,
+            branch: detectGitBranch(normalizedRootPath),
+            config: loadSpaceConfig(normalizedRootPath),
+            sessions: [],
+        };
+        fs.mkdirSync(this.storeDir, { recursive: true });
+        saveSpaceConfig(normalizedRootPath, space.config);
+        this.persistSpace(space);
+        this.writeCurrentName(space.name);
+        return space;
+    }
+    switchSpace(name) {
+        const space = this.loadSpace(name);
+        this.writeCurrentName(space.name);
+        config.cwd = space.rootPath;
+    }
+    listSpaces() {
+        if (!fs.existsSync(this.storeDir))
+            return [];
+        return fs
+            .readdirSync(this.storeDir)
+            .filter((entry) => entry.endsWith('.json'))
+            .map((entry) => {
+            const file = path.join(this.storeDir, entry);
+            try {
+                const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+                return normalizeSpace(parsed, decodeURIComponent(path.basename(entry, '.json')));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((space) => space !== null)
+            .sort((left, right) => left.name.localeCompare(right.name));
+    }
+    currentSpace() {
+        const detected = this.detectSpaceFromCwd(this.cwdProvider());
+        if (detected)
+            return detected;
+        const name = this.readCurrentName();
+        if (!name)
+            return null;
+        try {
+            return this.loadSpace(name);
+        }
+        catch {
+            return null;
+        }
+    }
+    deleteSpace(name) {
+        const normalizedName = validateName(name);
+        const file = this.spaceFile(normalizedName);
+        if (!fs.existsSync(file)) {
+            throw new Error(`space not found: ${normalizedName}`);
+        }
+        fs.rmSync(file, { force: true });
+        if (this.readCurrentName() === normalizedName) {
+            const currentFile = this.currentFile();
+            if (fs.existsSync(currentFile))
+                fs.rmSync(currentFile, { force: true });
+        }
+    }
+    detectSpaceFromCwd(cwd) {
+        const normalizedCwd = path.resolve(cwd);
+        const matches = this.listSpaces().filter((space) => isWithinRoot(normalizedCwd, space.rootPath));
+        if (!matches.length)
+            return null;
+        return matches.sort((left, right) => right.rootPath.length - left.rootPath.length)[0] ?? null;
+    }
+    persistSpace(space) {
+        fs.mkdirSync(this.storeDir, { recursive: true });
+        fs.writeFileSync(this.spaceFile(space.name), `${JSON.stringify(space, null, 2)}\n`, 'utf8');
+    }
+    spaceFile(name) {
+        return path.join(this.storeDir, `${encodeURIComponent(validateName(name))}.json`);
+    }
+    currentFile() {
+        return path.join(this.storeDir, CURRENT_FILE);
+    }
+    readCurrentName() {
+        const file = this.currentFile();
+        if (!fs.existsSync(file))
+            return null;
+        const name = fs.readFileSync(file, 'utf8').trim();
+        return name || null;
+    }
+    writeCurrentName(name) {
+        fs.mkdirSync(this.storeDir, { recursive: true });
+        fs.writeFileSync(this.currentFile(), `${name}\n`, 'utf8');
+    }
+}
+export function spacesDir() {
+    return process.env[SPACES_ENV] || path.join(os.homedir(), '.icopilot', 'spaces');
+}
+function validateName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        throw new Error('space name is required');
+    }
+    return trimmed;
+}
+function normalizeSpace(raw, fallbackName) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error(`invalid space definition: ${fallbackName ?? 'unknown'}`);
+    }
+    const record = raw;
+    const name = typeof record.name === 'string' && record.name.trim() ? record.name.trim() : fallbackName;
+    const rootPath = typeof record.rootPath === 'string' ? path.resolve(record.rootPath) : '';
+    if (!name || !rootPath) {
+        throw new Error(`invalid space definition: ${fallbackName ?? 'unknown'}`);
+    }
+    const savedConfig = readConfig(record.config);
+    const fileConfig = loadSpaceConfig(rootPath);
+    return {
+        name,
+        rootPath,
+        branch: typeof record.branch === 'string' && record.branch.trim()
+            ? record.branch
+            : detectGitBranch(rootPath),
+        config: {
+            model: fileConfig.model ?? savedConfig.model,
+            systemPrompt: fileConfig.systemPrompt ?? savedConfig.systemPrompt,
+            tools: fileConfig.tools ?? savedConfig.tools,
+            contextFiles: fileConfig.contextFiles ?? savedConfig.contextFiles,
+            maxTokens: fileConfig.maxTokens ?? savedConfig.maxTokens,
+        },
+        sessions: Array.isArray(record.sessions)
+            ? record.sessions.filter((value) => typeof value === 'string')
+            : [],
+    };
+}
+function readConfig(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return {
+            ...DEFAULT_SPACE_CONFIG,
+            tools: [...(DEFAULT_SPACE_CONFIG.tools ?? [])],
+            contextFiles: [...(DEFAULT_SPACE_CONFIG.contextFiles ?? [])],
+        };
+    }
+    const record = raw;
+    return {
+        model: typeof record.model === 'string' ? record.model : undefined,
+        systemPrompt: typeof record.systemPrompt === 'string' ? record.systemPrompt : undefined,
+        tools: Array.isArray(record.tools)
+            ? record.tools.filter((value) => typeof value === 'string')
+            : [],
+        contextFiles: Array.isArray(record.contextFiles)
+            ? record.contextFiles.filter((value) => typeof value === 'string')
+            : [],
+        maxTokens: typeof record.maxTokens === 'number' ? record.maxTokens : undefined,
+    };
+}
+function isWithinRoot(cwd, rootPath) {
+    const relative = path.relative(rootPath, cwd);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function detectGitBranch(rootPath) {
+    const gitDir = resolveGitDir(rootPath);
+    if (!gitDir)
+        return undefined;
+    try {
+        const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf8').trim();
+        const match = /^ref:\s+refs\/heads\/(.+)$/.exec(head);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveGitDir(rootPath) {
+    const gitPath = path.join(rootPath, '.git');
+    if (!fs.existsSync(gitPath))
+        return null;
+    if (fs.statSync(gitPath).isDirectory())
+        return gitPath;
+    try {
+        const content = fs.readFileSync(gitPath, 'utf8').trim();
+        const match = /^gitdir:\s+(.+)$/i.exec(content);
+        if (!match)
+            return null;
+        return path.resolve(rootPath, match[1].trim());
+    }
+    catch {
+        return null;
+    }
+}

package/dist/stats/store.js

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+let defaultFirstSeen;
+export function statsPath() {
+    return process.env.ICOPILOT_STATS_PATH || path.join(os.homedir(), '.icopilot', 'stats.json');
+}
+export function loadStats() {
+    const file = statsPath();
+    if (fs.existsSync(file)) {
+        try {
+            return normalizeStats(JSON.parse(fs.readFileSync(file, 'utf8')));
+        }
+        catch {
+            return defaultStats();
+        }
+    }
+    return defaultStats();
+}
+export function saveStats(s) {
+    const file = statsPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(normalizeStats(s), null, 2)}\n`, 'utf8');
+}
+export function recordTokens(input, output) {
+    const s = touch(loadStats());
+    s.tokensIn += count(input);
+    s.tokensOut += count(output);
+    saveStats(s);
+    return s;
+}
+export function recordToolCall(name) {
+    const s = touch(loadStats());
+    increment(s.toolCalls, name);
+    saveStats(s);
+    return s;
+}
+export function recordCommand(name) {
+    const s = touch(loadStats());
+    increment(s.commands, name);
+    saveStats(s);
+    return s;
+}
+export function recordSession() {
+    const s = touch(loadStats());
+    s.sessions += 1;
+    saveStats(s);
+    return s;
+}
+export function resetStats() {
+    const now = new Date().toISOString();
+    saveStats(zeroStats(now));
+}
+function defaultStats() {
+    defaultFirstSeen ??= new Date().toISOString();
+    return zeroStats(defaultFirstSeen);
+}
+function zeroStats(now) {
+    return {
+        firstSeen: now,
+        lastUpdate: now,
+        tokensIn: 0,
+        tokensOut: 0,
+        toolCalls: {},
+        commands: {},
+        sessions: 0,
+    };
+}
+function normalizeStats(value) {
+    const source = typeof value === 'object' && value !== null ? value : {};
+    const fallback = defaultStats();
+    return {
+        firstSeen: typeof source.firstSeen === 'string' ? source.firstSeen : fallback.firstSeen,
+        lastUpdate: typeof source.lastUpdate === 'string' ? source.lastUpdate : fallback.lastUpdate,
+        tokensIn: count(source.tokensIn),
+        tokensOut: count(source.tokensOut),
+        toolCalls: normalizeCounter(source.toolCalls),
+        commands: normalizeCounter(source.commands),
+        sessions: count(source.sessions),
+    };
+}
+function normalizeCounter(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => key.length > 0)
+        .map(([key, val]) => [key, count(val)]));
+}
+function touch(s) {
+    s.lastUpdate = new Date().toISOString();
+    return s;
+}
+function increment(target, name) {
+    const key = name.trim();
+    if (!key)
+        return;
+    target[key] = (target[key] || 0) + 1;
+}
+function count(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}

package/dist/tools/apply-patch.js

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { checkbox } from '@inquirer/prompts';
+import { applyPatch, parsePatch } from 'diff';
+import { config } from '../config.js';
+import { hookManager } from '../hooks/lifecycle.js';
+import { theme } from '../ui/theme.js';
+import { formatAutoCheckResult, runAutoLint } from './auto-check.js';
+import { loadPolicy, writePathAllowed } from './policy.js';
+import { assertSandbox } from './sandbox.js';
+import { toolMemory } from './memory.js';
+import { ensureWriteAllowed } from './file-ops.js';
+export async function applyPatchTool(args) {
+    const parsed = parsePatch(args.patch);
+    process.stdout.write('\n' + theme.badge('PATCH') + '\n');
+    process.stdout.write(colorizePatch(args.patch) + '\n');
+    const choices = parsed.flatMap((filePatch, fileIndex) => filePatch.hunks.map((hunk, hunkIndex) => ({
+        name: `${displayPath(filePatch)} @@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines}`,
+        value: `${fileIndex}:${hunkIndex}`,
+        checked: true,
+    })));
+    const selected = new Set(choices.length
+        ? await checkbox({
+            message: 'Select hunks to apply',
+            choices,
+        }).catch(() => [])
+        : []);
+    const policy = loadPolicy(config.cwd);
+    const applied = [];
+    const skipped = [];
+    const errors = [];
+    for (let fileIndex = 0; fileIndex < parsed.length; fileIndex += 1) {
+        const filePatch = parsed[fileIndex];
+        if (!filePatch)
+            continue;
+        const selectedHunks = filePatch.hunks
+            .map((hunk, hunkIndex) => ({ hunk, hunkIndex }))
+            .filter(({ hunkIndex }) => selected.has(`${fileIndex}:${hunkIndex}`));
+        const unselected = filePatch.hunks
+            .map((_, hunkIndex) => hunkIndex)
+            .filter((hunkIndex) => !selected.has(`${fileIndex}:${hunkIndex}`));
+        if (unselected.length) {
+            skipped.push({ path: displayPath(filePatch), hunks: unselected, reason: 'not selected' });
+        }
+        if (!selectedHunks.length)
+            continue;
+        const relPath = normalizePatchPath(displayPath(filePatch));
+        const abs = path.resolve(config.cwd, relPath);
+        try {
+            const denied = ensureWriteAllowed(abs);
+            if (denied) {
+                skipped.push({
+                    path: relPath,
+                    hunks: selectedHunks.map(({ hunkIndex }) => hunkIndex),
+                    reason: denied,
+                });
+                continue;
+            }
+            assertSandbox(abs, config.cwd);
+            if (!toolMemory.isWriteRemembered(abs) && !writePathAllowed(abs, policy, config.cwd)) {
+                skipped.push({
+                    path: relPath,
+                    hunks: selectedHunks.map(({ hunkIndex }) => hunkIndex),
+                    reason: 'policy denied',
+                });
+                continue;
+            }
+            const oldContent = fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : '';
+            const partial = clonePatchWithHunks(filePatch, selectedHunks.map(({ hunk }) => hunk));
+            const next = applyPatch(oldContent, partial);
+            if (next === false) {
+                errors.push({ path: relPath, error: 'patch did not apply' });
+                continue;
+            }
+            fs.mkdirSync(path.dirname(abs), { recursive: true });
+            fs.writeFileSync(abs, next, 'utf8');
+            await hookManager.emit('fileChanged', {
+                cwd: config.cwd,
+                path: relPath,
+                absolutePath: abs,
+            });
+            applied.push({ path: relPath, hunks: selectedHunks.map(({ hunkIndex }) => hunkIndex) });
+        }
+        catch (e) {
+            errors.push({ path: relPath, error: e?.message || String(e) });
+        }
+    }
+    const changedFiles = applied.map((entry) => entry.path);
+    const autoLint = errors.length === 0 ? await maybeRunAutoLint(changedFiles) : undefined;
+    return JSON.stringify({ applied, skipped, errors, ...(autoLint ? { autoLint } : {}) });
+}
+function clonePatchWithHunks(filePatch, hunks) {
+    return {
+        ...filePatch,
+        hunks: hunks.map((hunk) => ({
+            ...hunk,
+            lines: [...hunk.lines],
+            linedelimiters: hunk.linedelimiters ? [...hunk.linedelimiters] : undefined,
+        })),
+    };
+}
+function displayPath(filePatch) {
+    return filePatch.newFileName && filePatch.newFileName !== '/dev/null'
+        ? filePatch.newFileName
+        : filePatch.oldFileName || '';
+}
+function normalizePatchPath(file) {
+    return file.replace(/\\/g, '/').replace(/^(a|b)\//, '');
+}
+function colorizePatch(p) {
+    return p
+        .split('\n')
+        .map((l) => {
+        if (l.startsWith('+++') || l.startsWith('---'))
+            return theme.dim(l);
+        if (l.startsWith('+'))
+            return theme.ok(l);
+        if (l.startsWith('-'))
+            return theme.err(l);
+        if (l.startsWith('@@'))
+            return theme.hl(l);
+        return l;
+    })
+        .join('\n');
+}
+async function maybeRunAutoLint(changedFiles) {
+    if (!config.autoLint || changedFiles.length === 0)
+        return undefined;
+    const result = await runAutoLint(changedFiles);
+    if (!config.quiet && !config.jsonOutput) {
+        process.stdout.write(`${theme.dim(formatAutoCheckResult('lint', result, changedFiles))}\n`);
+    }
+    return result;
+}