icopilot 2.2.0

package/dist/commands/readme-cmd.js

@@ -0,0 +1,564 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { detectPackageManager } from './deps-cmd.js';
+import { theme } from '../ui/theme.js';
+const SECTION_ORDER = [
+    'title',
+    'badges',
+    'description',
+    'install',
+    'usage',
+    'api',
+    'scripts',
+    'contributing',
+    'license',
+];
+const SECTION_HEADINGS = {
+    install: 'Install',
+    usage: 'Usage',
+    api: 'API',
+    scripts: 'Scripts',
+    contributing: 'Contributing',
+    license: 'License',
+};
+const README_NAME = 'README.md';
+export function generateReadme(rootDir, opts = {}) {
+    const ctx = analyzeReadmeContext(rootDir);
+    const sections = resolveSections(opts);
+    const blocks = renderBlocks(ctx);
+    return sections
+        .map((section) => blocks[section]?.trim())
+        .filter((section) => Boolean(section))
+        .join('\n\n')
+        .trim()
+        .concat('\n');
+}
+export function analyzeProject(rootDir) {
+    return analyzeReadmeContext(rootDir).analysis;
+}
+export function readmeCommand(args, cwd) {
+    const parsed = parseReadmeArgs(args);
+    if (parsed.error) {
+        return `${theme.warn(parsed.error)}\n`;
+    }
+    const readmePath = path.join(cwd, README_NAME);
+    if (parsed.mode === 'preview') {
+        return `${theme.brand('Generated README preview')}\n\n${generateReadme(cwd, parsed.options)}`;
+    }
+    if (parsed.mode === 'update') {
+        const next = updateExistingReadme(cwd, parsed.options);
+        fs.writeFileSync(readmePath, next, 'utf8');
+        return `${theme.ok(`Updated ${README_NAME}.`)}\n`;
+    }
+    if (fs.existsSync(readmePath) && !parsed.options.overwrite) {
+        return `${theme.warn(`${README_NAME} already exists.`)}\n${theme.dim('Use /readme update, /readme preview, or /readme --overwrite.')}\n`;
+    }
+    fs.writeFileSync(readmePath, generateReadme(cwd, parsed.options), 'utf8');
+    return `${theme.ok(`Wrote ${README_NAME}.`)}\n`;
+}
+function analyzeReadmeContext(rootDir) {
+    const packageJson = readPackageJson(rootDir);
+    const scripts = normalizeScripts(packageJson?.scripts);
+    const cliNames = collectCliNames(packageJson);
+    const entry = detectEntry(rootDir, packageJson);
+    const analysis = {
+        name: packageJson?.name?.trim() || path.basename(path.resolve(rootDir)),
+        description: packageJson?.description?.trim() ||
+            `Project scaffold for ${detectLanguage(rootDir, packageJson)} workflows.`,
+        language: detectLanguage(rootDir, packageJson),
+        packageManager: detectPackageManager(rootDir) ?? (packageJson ? 'npm' : 'unknown'),
+        scripts,
+        entry,
+        license: detectLicense(rootDir, packageJson),
+    };
+    const entrySource = resolveEntrySource(rootDir, packageJson, entry);
+    const entryText = entrySource ? safeRead(path.join(rootDir, entrySource)) : undefined;
+    return {
+        analysis,
+        packageJson,
+        cliNames,
+        cliCommands: entryText ? scanCliCommands(entryText) : [],
+        exportsList: collectExports(packageJson),
+        dependencies: collectDependencies(packageJson),
+        installSteps: buildInstallSteps(analysis, cliNames),
+        usageExamples: buildUsageExamples(analysis, cliNames, entryText),
+        contributingFile: detectContributingFile(rootDir),
+        rootDir,
+    };
+}
+function renderBlocks(ctx) {
+    return {
+        title: `# ${ctx.analysis.name}`,
+        badges: renderBadges(ctx),
+        description: ctx.analysis.description,
+        install: renderTitledSection('install', renderInstall(ctx)),
+        usage: renderTitledSection('usage', renderUsage(ctx)),
+        api: renderTitledSection('api', renderApi(ctx)),
+        scripts: renderTitledSection('scripts', renderScripts(ctx)),
+        contributing: renderTitledSection('contributing', renderContributing(ctx)),
+        license: renderTitledSection('license', renderLicense(ctx)),
+    };
+}
+function renderBadges(ctx) {
+    const badges = [];
+    const engine = ctx.packageJson?.engines?.node;
+    if (engine) {
+        badges.push(`![Node](https://img.shields.io/badge/node-${encodeBadgeValue(engine)}-339933?logo=node.js)`);
+    }
+    if (ctx.analysis.language !== 'Unknown') {
+        const langColor = ctx.analysis.language === 'TypeScript'
+            ? '3178C6'
+            : ctx.analysis.language === 'JavaScript'
+                ? 'F7DF1E'
+                : '6E7781';
+        badges.push(`![Language](https://img.shields.io/badge/language-${encodeBadgeValue(ctx.analysis.language)}-${langColor})`);
+    }
+    if (ctx.analysis.license !== 'UNLICENSED') {
+        badges.push(`![License](https://img.shields.io/badge/license-${encodeBadgeValue(ctx.analysis.license)}-blue.svg)`);
+    }
+    return badges.join('\n');
+}
+function renderInstall(ctx) {
+    const lines = ctx.installSteps.length > 0 ? ctx.installSteps : defaultInstallSteps(ctx.analysis);
+    return toCodeFence(lines);
+}
+function renderUsage(ctx) {
+    const examples = ctx.usageExamples.length > 0 ? ctx.usageExamples : defaultUsageExamples(ctx.analysis);
+    return toCodeFence(examples);
+}
+function renderApi(ctx) {
+    const lines = [
+        `- Language: ${ctx.analysis.language}`,
+        `- Package manager: ${ctx.analysis.packageManager}`,
+        `- Entry: \`${ctx.analysis.entry}\``,
+    ];
+    if (ctx.cliNames.length > 0) {
+        lines.push(`- CLI binaries: ${ctx.cliNames.map((name) => `\`${name}\``).join(', ')}`);
+    }
+    if (ctx.exportsList.length > 0) {
+        lines.push('- Exports:');
+        for (const entry of ctx.exportsList)
+            lines.push(`  - \`${entry}\``);
+    }
+    if (ctx.cliCommands.length > 0) {
+        lines.push('- CLI commands:');
+        for (const command of ctx.cliCommands.slice(0, 8))
+            lines.push(`  - \`${command}\``);
+    }
+    if (ctx.dependencies.length > 0) {
+        lines.push('- Dependencies:');
+        for (const dependency of ctx.dependencies.slice(0, 16)) {
+            lines.push(`  - [${dependency.type}] \`${dependency.name}\` — ${dependency.version}`);
+        }
+    }
+    return lines.join('\n');
+}
+function renderScripts(ctx) {
+    const entries = Object.entries(ctx.analysis.scripts);
+    if (entries.length === 0) {
+        return '- No package scripts were detected.';
+    }
+    return entries.map(([name, command]) => `- \`${name}\`: \`${command}\``).join('\n');
+}
+function renderContributing(ctx) {
+    const lines = [];
+    if (ctx.contributingFile) {
+        lines.push(`See [${ctx.contributingFile}](./${ctx.contributingFile}) for project-specific guidelines.`);
+    }
+    else {
+        lines.push('Contributions are welcome. Start by installing dependencies and running the local quality checks:');
+    }
+    const checks = buildContributingChecks(ctx.analysis);
+    if (checks.length > 0) {
+        lines.push('', ...checks.map((command) => `- \`${command}\``));
+    }
+    return lines.join('\n');
+}
+function renderLicense(ctx) {
+    const hasLicenseFile = fs.existsSync(path.join(ctx.rootDir, 'LICENSE'));
+    return hasLicenseFile
+        ? `Licensed under the ${ctx.analysis.license} license. See [LICENSE](./LICENSE).`
+        : `Licensed under the ${ctx.analysis.license} license.`;
+}
+function renderTitledSection(section, body) {
+    return `## ${SECTION_HEADINGS[section]}\n\n${body.trim()}`;
+}
+function updateExistingReadme(rootDir, opts) {
+    const readmePath = path.join(rootDir, README_NAME);
+    if (!fs.existsSync(readmePath)) {
+        return generateReadme(rootDir, opts);
+    }
+    const existing = fs.readFileSync(readmePath, 'utf8');
+    const sections = resolveSections(opts);
+    const blocks = renderBlocks(analyzeReadmeContext(rootDir));
+    let next = existing;
+    if (sections.some((section) => section === 'title' || section === 'badges' || section === 'description')) {
+        const preamble = SECTION_ORDER.filter((section) => (section === 'title' || section === 'badges' || section === 'description') &&
+            sections.includes(section))
+            .map((section) => blocks[section].trim())
+            .filter(Boolean)
+            .join('\n\n');
+        const firstHeadingMatch = next.match(/^##\s+/m);
+        const suffix = firstHeadingMatch ? next.slice(firstHeadingMatch.index ?? 0).trimStart() : '';
+        next = [preamble, suffix].filter(Boolean).join('\n\n').trim().concat('\n');
+    }
+    for (const section of sections) {
+        if (section === 'title' || section === 'badges' || section === 'description')
+            continue;
+        next = replaceSection(next, SECTION_HEADINGS[section], blocks[section]);
+    }
+    return next.endsWith('\n') ? next : `${next}\n`;
+}
+function replaceSection(readme, heading, block) {
+    const escapedHeading = escapeRegExp(heading);
+    const sectionPattern = new RegExp(`(^## ${escapedHeading}\\n[\\s\\S]*?)(?=^## \\S|\\Z)`, 'm');
+    if (sectionPattern.test(readme)) {
+        return readme.replace(sectionPattern, `${block.trim()}\n\n`);
+    }
+    return `${readme.trim()}\n\n${block.trim()}\n`;
+}
+function parseReadmeArgs(args) {
+    const options = {};
+    let mode = 'generate';
+    let index = 0;
+    if (args[0] === 'preview' || args[0] === 'update') {
+        mode = args[0];
+        index = 1;
+    }
+    while (index < args.length) {
+        const token = args[index];
+        if (token === '--overwrite') {
+            options.overwrite = true;
+            index += 1;
+            continue;
+        }
+        if (token === '--template') {
+            const value = args[index + 1];
+            if (!value)
+                return {
+                    mode,
+                    options,
+                    error: 'usage: /readme [preview|update] [--template <name>] [--sections a,b] [--overwrite]',
+                };
+            options.template = value;
+            index += 2;
+            continue;
+        }
+        if (token.startsWith('--template=')) {
+            options.template = token.slice('--template='.length);
+            index += 1;
+            continue;
+        }
+        if (token === '--sections') {
+            const value = args[index + 1];
+            if (!value)
+                return {
+                    mode,
+                    options,
+                    error: 'usage: /readme [preview|update] [--template <name>] [--sections a,b] [--overwrite]',
+                };
+            options.sections = splitSections(value);
+            index += 2;
+            continue;
+        }
+        if (token.startsWith('--sections=')) {
+            options.sections = splitSections(token.slice('--sections='.length));
+            index += 1;
+            continue;
+        }
+        return {
+            mode,
+            options,
+            error: `unknown /readme argument: ${token}`,
+        };
+    }
+    return { mode, options };
+}
+function resolveSections(opts) {
+    const requested = (opts.sections ?? defaultSectionsForTemplate(opts.template))
+        .map((section) => section.trim().toLowerCase())
+        .filter(Boolean);
+    const resolved = requested.filter((section) => SECTION_ORDER.includes(section));
+    return resolved.length > 0 ? resolved : [...SECTION_ORDER];
+}
+function defaultSectionsForTemplate(template) {
+    if (template === 'minimal') {
+        return ['title', 'description', 'install', 'usage', 'license'];
+    }
+    return [...SECTION_ORDER];
+}
+function splitSections(value) {
+    return value
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+function readPackageJson(rootDir) {
+    const packageJsonPath = path.join(rootDir, 'package.json');
+    const text = safeRead(packageJsonPath);
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeScripts(scripts) {
+    return Object.fromEntries(Object.entries(scripts ?? {}).sort(([left], [right]) => left.localeCompare(right)));
+}
+function collectCliNames(packageJson) {
+    if (!packageJson?.bin)
+        return [];
+    if (typeof packageJson.bin === 'string') {
+        return packageJson.name ? [packageJson.name] : [];
+    }
+    return Object.keys(packageJson.bin).sort((left, right) => left.localeCompare(right));
+}
+function detectEntry(rootDir, packageJson) {
+    const binPath = typeof packageJson?.bin === 'string'
+        ? packageJson.bin
+        : packageJson?.bin
+            ? Object.values(packageJson.bin)[0]
+            : undefined;
+    const normalizedBinPath = normalizeRelative(binPath);
+    if (normalizedBinPath)
+        return normalizedBinPath;
+    if (packageJson?.main)
+        return normalizeRelative(packageJson.main);
+    const fallbacks = ['src/index.ts', 'src/cli.ts', 'index.ts', 'index.js'];
+    for (const candidate of fallbacks) {
+        if (fs.existsSync(path.join(rootDir, candidate)))
+            return candidate;
+    }
+    return 'src/index.ts';
+}
+function resolveEntrySource(rootDir, packageJson, entry) {
+    if (entry.endsWith('.ts') && fs.existsSync(path.join(rootDir, entry))) {
+        return entry;
+    }
+    if (entry.endsWith('.js')) {
+        const directTs = entry.replace(/^dist\//u, 'src/').replace(/\.js$/u, '.ts');
+        if (fs.existsSync(path.join(rootDir, directTs)))
+            return directTs;
+        const entryText = safeRead(path.join(rootDir, entry));
+        const distImport = entryText?.match(/(?:import\s+['"]\.\.\/dist\/([^'"]+)\.js['"]|require\(['"]\.\.\/dist\/([^'"]+)\.js['"]\))/u);
+        const sourceStem = distImport?.[1] ?? distImport?.[2];
+        if (sourceStem) {
+            const sourcePath = path.join('src', `${sourceStem}.ts`);
+            if (fs.existsSync(path.join(rootDir, sourcePath)))
+                return sourcePath;
+        }
+    }
+    if (packageJson?.main) {
+        const candidate = packageJson.main.replace(/^dist\//u, 'src/').replace(/\.js$/u, '.ts');
+        if (fs.existsSync(path.join(rootDir, candidate)))
+            return candidate;
+    }
+    return undefined;
+}
+function detectLanguage(rootDir, packageJson) {
+    if (fs.existsSync(path.join(rootDir, 'tsconfig.json')))
+        return 'TypeScript';
+    if (hasFileWithExtension(rootDir, '.ts'))
+        return 'TypeScript';
+    if (packageJson?.type === 'module' || fs.existsSync(path.join(rootDir, 'package.json'))) {
+        return 'JavaScript';
+    }
+    if (fs.existsSync(path.join(rootDir, 'pyproject.toml')) ||
+        fs.existsSync(path.join(rootDir, 'requirements.txt'))) {
+        return 'Python';
+    }
+    return 'Unknown';
+}
+function detectLicense(rootDir, packageJson) {
+    if (packageJson?.license?.trim())
+        return packageJson.license.trim();
+    const licenseText = safeRead(path.join(rootDir, 'LICENSE'));
+    if (!licenseText)
+        return 'UNLICENSED';
+    const firstLine = licenseText.split(/\r?\n/u)[0]?.trim();
+    return firstLine?.replace(/\s+License$/u, '') || 'UNLICENSED';
+}
+function collectDependencies(packageJson) {
+    const prod = Object.entries(packageJson?.dependencies ?? {}).map(([name, version]) => ({
+        name,
+        version,
+        type: 'prod',
+    }));
+    const dev = Object.entries(packageJson?.devDependencies ?? {}).map(([name, version]) => ({
+        name,
+        version,
+        type: 'dev',
+    }));
+    return [...prod, ...dev].sort((left, right) => left.name.localeCompare(right.name));
+}
+function buildInstallSteps(analysis, cliNames) {
+    switch (analysis.packageManager) {
+        case 'npm':
+            return cliNames.length > 0
+                ? [
+                    'npm install',
+                    hasScript(analysis.scripts, 'build') ? 'npm run build' : '',
+                    'npm link',
+                ].filter(Boolean)
+                : ['npm install', hasScript(analysis.scripts, 'build') ? 'npm run build' : ''].filter(Boolean);
+        case 'pnpm':
+            return cliNames.length > 0
+                ? [
+                    'pnpm install',
+                    hasScript(analysis.scripts, 'build') ? 'pnpm run build' : '',
+                    'pnpm link --global',
+                ].filter(Boolean)
+                : ['pnpm install', hasScript(analysis.scripts, 'build') ? 'pnpm run build' : ''].filter(Boolean);
+        case 'yarn':
+            return ['yarn install', hasScript(analysis.scripts, 'build') ? 'yarn build' : ''].filter(Boolean);
+        case 'pip':
+            return ['pip install -r requirements.txt'];
+        default:
+            return defaultInstallSteps(analysis);
+    }
+}
+function defaultInstallSteps(analysis) {
+    if (analysis.language === 'TypeScript' || analysis.language === 'JavaScript') {
+        return ['npm install'];
+    }
+    return ['Follow the project-specific setup workflow for this repository.'];
+}
+function buildUsageExamples(analysis, cliNames, entryText) {
+    const examples = [];
+    const cli = cliNames[0];
+    const commands = entryText ? scanCliCommands(entryText) : [];
+    if (cli) {
+        examples.push(`${cli} --help`);
+        for (const command of commands.slice(0, 3)) {
+            examples.push(`${cli} ${command}`);
+        }
+    }
+    if (examples.length === 0 && hasScript(analysis.scripts, 'start')) {
+        examples.push(runScriptCommand(analysis.packageManager, 'start'));
+    }
+    if (examples.length === 0 && analysis.entry) {
+        examples.push(`node ${analysis.entry}`);
+    }
+    return unique(examples);
+}
+function defaultUsageExamples(analysis) {
+    if (hasScript(analysis.scripts, 'start')) {
+        return [runScriptCommand(analysis.packageManager, 'start')];
+    }
+    return [`node ${analysis.entry}`];
+}
+function scanCliCommands(entryText) {
+    const commands = Array.from(entryText.matchAll(/\.command\(\s*['"`]([^'"`]+?)['"`]\s*\)/gu)).map((match) => match[1].trim());
+    return unique(commands);
+}
+function collectExports(packageJson) {
+    if (!packageJson)
+        return [];
+    const entries = [];
+    flattenExports(packageJson.exports, '.', entries);
+    if (entries.length === 0 && packageJson.main)
+        entries.push(`main -> ${normalizeRelative(packageJson.main)}`);
+    return unique(entries);
+}
+function flattenExports(value, key, acc) {
+    if (!value)
+        return;
+    if (typeof value === 'string') {
+        acc.push(`${key} -> ${normalizeRelative(value)}`);
+        return;
+    }
+    if (typeof value !== 'object' || Array.isArray(value))
+        return;
+    for (const [nestedKey, nestedValue] of Object.entries(value)) {
+        if (typeof nestedValue === 'string') {
+            acc.push(`${key === '.' ? nestedKey : `${key}.${nestedKey}`} -> ${normalizeRelative(nestedValue)}`);
+            continue;
+        }
+        if (nestedValue && typeof nestedValue === 'object' && !Array.isArray(nestedValue)) {
+            flattenExports(nestedValue, key === '.' ? nestedKey : `${key}.${nestedKey}`, acc);
+        }
+    }
+}
+function detectContributingFile(rootDir) {
+    const candidates = ['CONTRIBUTING.md', 'CONTRIBUTING', 'docs/CONTRIBUTING.md'];
+    return candidates.find((candidate) => fs.existsSync(path.join(rootDir, candidate)));
+}
+function buildContributingChecks(analysis) {
+    const commands = [];
+    if (hasScript(analysis.scripts, 'lint'))
+        commands.push(runScriptCommand(analysis.packageManager, 'lint'));
+    if (hasScript(analysis.scripts, 'test'))
+        commands.push(runScriptCommand(analysis.packageManager, 'test'));
+    if (hasScript(analysis.scripts, 'build'))
+        commands.push(runScriptCommand(analysis.packageManager, 'build'));
+    return unique(commands);
+}
+function runScriptCommand(packageManager, script) {
+    switch (packageManager) {
+        case 'yarn':
+            return `yarn ${script}`;
+        case 'pnpm':
+            return `pnpm run ${script}`;
+        default:
+            return `npm run ${script}`;
+    }
+}
+function hasScript(scripts, name) {
+    return typeof scripts[name] === 'string' && scripts[name].length > 0;
+}
+function safeRead(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasFileWithExtension(rootDir, extension) {
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const dirPath = stack.pop();
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist')
+                continue;
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith(extension)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function normalizeRelative(value) {
+    if (!value)
+        return '';
+    return value
+        .replace(/^[.][/\\]/u, '')
+        .split(path.sep)
+        .join('/');
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+function toCodeFence(lines) {
+    return ['```bash', ...lines, '```'].join('\n');
+}
+function encodeBadgeValue(value) {
+    return encodeURIComponent(value).replace(/-/gu, '--');
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}

package/dist/commands/reasoning-cmd.js

@@ -0,0 +1,34 @@
+import { config } from '../config.js';
+export function setReasoningEffort(level) {
+    config.reasoningEffort = level;
+}
+export function setThinkTokens(budget) {
+    if (budget === null) {
+        config.thinkTokens = undefined;
+        return;
+    }
+    if (!Number.isFinite(budget) || budget < 0) {
+        throw new Error('think token budget must be a non-negative number');
+    }
+    config.thinkTokens = Math.floor(budget);
+}
+export function parseTokenBudget(input) {
+    const trimmed = input.trim();
+    const match = trimmed.match(/^(\d+(?:\.\d+)?)([kKmM]?)$/);
+    if (!match) {
+        throw new Error(`invalid token budget: ${input}`);
+    }
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || amount < 0) {
+        throw new Error(`invalid token budget: ${input}`);
+    }
+    const suffix = match[2].toLowerCase();
+    const multiplier = suffix === 'k' ? 1024 : suffix === 'm' ? 1024 * 1024 : 1;
+    return Math.round(amount * multiplier);
+}
+export function getReasoningConfig() {
+    return {
+        ...(config.reasoningEffort ? { effort: config.reasoningEffort } : {}),
+        ...(typeof config.thinkTokens === 'number' ? { thinkTokens: config.thinkTokens } : {}),
+    };
+}

package/dist/commands/refactor-cmd.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { theme } from '../ui/theme.js';
+function usage() {
+    return [
+        theme.brand('Refactor command'),
+        '  /refactor rename <old> <new> [path]    build a rename-symbol refactor prompt',
+        '  /refactor extract <path> <lines>       build an extract-function refactor prompt',
+        '  /refactor inline <path> <symbol>       build an inline-symbol refactor prompt',
+        '',
+    ].join('\n');
+}
+function renderPayload(payload) {
+    return `${theme.hl(payload.description)}\n${payload.prompt}\n`;
+}
+function renderError(message) {
+    return `${theme.err(message)}\n`;
+}
+function resolveExistingPath(cwd, target) {
+    const resolvedPath = path.resolve(cwd, target);
+    return fs.existsSync(resolvedPath) ? resolvedPath : undefined;
+}
+function buildRenamePayload(args, cwd) {
+    const [oldSymbol, newSymbol, targetPath] = args;
+    if (!oldSymbol || !newSymbol) {
+        return renderError('usage: /refactor rename <old> <new> [path]');
+    }
+    let scope = `across the workspace rooted at ${cwd}`;
+    if (targetPath) {
+        const resolvedPath = resolveExistingPath(cwd, targetPath);
+        if (!resolvedPath) {
+            return renderError(`target file not found: ${path.resolve(cwd, targetPath)}`);
+        }
+        scope = `starting from ${resolvedPath} and any related files`;
+    }
+    const payload = {
+        kind: 'rename',
+        description: `Refactor intent: rename "${oldSymbol}" to "${newSymbol}"`,
+        prompt: `Rename the symbol "${oldSymbol}" to "${newSymbol}" ${scope}. ` +
+            'Update all references, imports, exports, and type usages consistently. ' +
+            'Avoid unrelated edits and preserve behavior.',
+    };
+    return renderPayload(payload);
+}
+function buildExtractPayload(args, cwd) {
+    const [targetPath, lines] = args;
+    if (!targetPath || !lines) {
+        return renderError('usage: /refactor extract <path> <lines>');
+    }
+    const resolvedPath = resolveExistingPath(cwd, targetPath);
+    if (!resolvedPath) {
+        return renderError(`target file not found: ${path.resolve(cwd, targetPath)}`);
+    }
+    const payload = {
+        kind: 'extract',
+        description: `Refactor intent: extract a function from ${path.basename(resolvedPath)}:${lines}`,
+        prompt: `Extract a well-named function from lines ${lines} in ${resolvedPath}. ` +
+            'Preserve the current behavior, keep dependencies explicit, and update the original call site to use the new function. ' +
+            'Prefer a minimal, readable refactor.',
+    };
+    return renderPayload(payload);
+}
+function buildInlinePayload(args, cwd) {
+    const [targetPath, symbol] = args;
+    if (!targetPath || !symbol) {
+        return renderError('usage: /refactor inline <path> <symbol>');
+    }
+    const resolvedPath = resolveExistingPath(cwd, targetPath);
+    if (!resolvedPath) {
+        return renderError(`target file not found: ${path.resolve(cwd, targetPath)}`);
+    }
+    const payload = {
+        kind: 'inline',
+        description: `Refactor intent: inline "${symbol}" in ${path.basename(resolvedPath)}`,
+        prompt: `Inline the symbol "${symbol}" in ${resolvedPath}. ` +
+            'Replace its usages with the underlying expression or implementation where appropriate, remove the obsolete declaration if safe, ' +
+            'and keep the file behavior unchanged.',
+    };
+    return renderPayload(payload);
+}
+export function refactorCommand(args, cwd) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        return usage();
+    }
+    switch (subcommand.toLowerCase()) {
+        case 'rename':
+            return buildRenamePayload(rest, cwd);
+        case 'extract':
+            return buildExtractPayload(rest, cwd);
+        case 'inline':
+            return buildInlinePayload(rest, cwd);
+        default:
+            return `${theme.warn(`unknown refactor subcommand: ${subcommand}`)}\n${usage()}`;
+    }
+}