icopilot 2.2.0

package/dist/commands/release-cmd.js

@@ -0,0 +1,450 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import simpleGit from 'simple-git';
+import { config } from '../config.js';
+import { theme } from '../ui/theme.js';
+const RELEASE_TYPES = [
+    'major',
+    'minor',
+    'patch',
+    'premajor',
+    'preminor',
+    'prepatch',
+];
+const DEFAULT_CHANGELOG = `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+`;
+const SECTION_ORDER = [
+    'Breaking Changes',
+    'Features',
+    'Fixes',
+    'Documentation',
+    'Performance',
+    'Refactors',
+    'Tests',
+    'Build',
+    'CI',
+    'Chores',
+    'Reverts',
+    'Other',
+];
+export async function performRelease(opts) {
+    return performReleaseAt(opts, config.cwd);
+}
+export async function releaseCommand(args, cwd) {
+    let parsed;
+    try {
+        parsed = parseReleaseArgs(args);
+    }
+    catch (error) {
+        return `${theme.warn(error.message)}\n`;
+    }
+    if (parsed.mode === 'status') {
+        const snapshot = await getReleaseSnapshot(cwd);
+        return formatStatus(snapshot);
+    }
+    const options = parsed.mode === 'preview'
+        ? {
+            ...parsed.options,
+            dryRun: true,
+            skipPublish: true,
+        }
+        : parsed.options;
+    try {
+        const result = await performReleaseAt(options, cwd);
+        return parsed.mode === 'preview' ? formatPreview(result) : formatReleaseResult(result);
+    }
+    catch (error) {
+        return `${theme.err(`release failed: ${error.message}`)}\n`;
+    }
+}
+export function calculateNextVersion(currentVersion, type) {
+    const version = parseSemver(currentVersion);
+    switch (type) {
+        case 'major':
+            return formatSemver({ major: version.major + 1, minor: 0, patch: 0 });
+        case 'minor':
+            return formatSemver({ major: version.major, minor: version.minor + 1, patch: 0 });
+        case 'patch':
+            return formatSemver({ major: version.major, minor: version.minor, patch: version.patch + 1 });
+        case 'premajor':
+            return formatPrerelease({ major: version.major + 1, minor: 0, patch: 0 }, version);
+        case 'preminor':
+            return formatPrerelease({ major: version.major, minor: version.minor + 1, patch: 0 }, version);
+        case 'prepatch':
+            return formatPrerelease({ major: version.major, minor: version.minor, patch: version.patch + 1 }, version);
+    }
+}
+export function parseSemver(version) {
+    const match = version
+        .trim()
+        .match(/^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>[0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!match?.groups) {
+        throw new Error(`unsupported semver version: ${version}`);
+    }
+    return {
+        major: Number.parseInt(match.groups.major, 10),
+        minor: Number.parseInt(match.groups.minor, 10),
+        patch: Number.parseInt(match.groups.patch, 10),
+        prerelease: match.groups.prerelease || undefined,
+    };
+}
+export function formatSemver(version) {
+    const core = `${version.major}.${version.minor}.${version.patch}`;
+    return version.prerelease ? `${core}-${version.prerelease}` : core;
+}
+async function performReleaseAt(opts, cwd) {
+    const snapshot = await getReleaseSnapshot(cwd);
+    if (snapshot.dirty && !opts.dryRun) {
+        throw new Error('working tree is dirty; commit or stash changes before releasing');
+    }
+    const nextVersion = calculateNextVersion(snapshot.currentVersion, opts.type);
+    const tagName = `v${nextVersion}`;
+    const changelogEntry = snapshot.unreleasedChanges || '- No changes recorded.';
+    if (opts.dryRun) {
+        return {
+            version: nextVersion,
+            changelog: changelogEntry,
+            tag: tagName,
+            published: false,
+        };
+    }
+    const git = simpleGit({ baseDir: cwd });
+    const originalPackageText = fs.readFileSync(snapshot.packagePath, 'utf8');
+    const originalChangelogText = fs.existsSync(snapshot.changelogPath)
+        ? fs.readFileSync(snapshot.changelogPath, 'utf8')
+        : undefined;
+    let packageUpdated = false;
+    let changelogUpdated = false;
+    let committed = false;
+    try {
+        const updatedPackage = {
+            ...snapshot.packageJson,
+            version: nextVersion,
+        };
+        fs.writeFileSync(snapshot.packagePath, `${JSON.stringify(updatedPackage, null, 2)}\n`, 'utf8');
+        packageUpdated = true;
+        const filesToAdd = ['package.json'];
+        if (!opts.skipChangelog) {
+            const nextChangelog = buildUpdatedChangelog(originalChangelogText, nextVersion, changelogEntry);
+            fs.writeFileSync(snapshot.changelogPath, nextChangelog, 'utf8');
+            changelogUpdated = true;
+            filesToAdd.push('CHANGELOG.md');
+        }
+        await git.add(filesToAdd);
+        await git.commit(`chore(release): ${tagName}`);
+        committed = true;
+        if (!opts.skipTag) {
+            await git.addTag(tagName);
+        }
+        let published = false;
+        if (!opts.skipPublish) {
+            runPublish(cwd, opts.tag);
+            published = true;
+            return {
+                version: nextVersion,
+                changelog: changelogEntry,
+                tag: tagName,
+                published,
+            };
+        }
+        return {
+            version: nextVersion,
+            changelog: changelogEntry,
+            tag: tagName,
+            published: false,
+        };
+    }
+    catch (error) {
+        if (!committed) {
+            if (packageUpdated) {
+                fs.writeFileSync(snapshot.packagePath, originalPackageText, 'utf8');
+            }
+            if (changelogUpdated) {
+                if (originalChangelogText === undefined) {
+                    fs.rmSync(snapshot.changelogPath, { force: true });
+                }
+                else {
+                    fs.writeFileSync(snapshot.changelogPath, originalChangelogText, 'utf8');
+                }
+            }
+        }
+        throw error;
+    }
+}
+async function getReleaseSnapshot(cwd) {
+    const git = simpleGit({ baseDir: cwd });
+    if (!(await git.checkIsRepo())) {
+        throw new Error(`not a git repository: ${cwd}`);
+    }
+    const packagePath = path.join(cwd, 'package.json');
+    const changelogPath = path.join(cwd, 'CHANGELOG.md');
+    const packageJson = readPackageJson(packagePath);
+    const currentVersion = readVersion(packageJson);
+    const latestTag = (await git.tags()).latest ?? null;
+    const commits = mapConventionalCommits(await readReleaseCommits(git, latestTag));
+    const unreleasedChanges = renderConventionalChangelog(commits);
+    const status = await git.status();
+    return {
+        cwd,
+        packagePath,
+        changelogPath,
+        packageJson,
+        currentVersion,
+        latestTag,
+        commits,
+        unreleasedChanges,
+        dirty: !status.isClean(),
+    };
+}
+async function readReleaseCommits(git, latestTag) {
+    const range = latestTag ? [`${latestTag}..HEAD`] : ['HEAD'];
+    const result = await git.log(range);
+    return Array.from(result.all);
+}
+function readPackageJson(packagePath) {
+    try {
+        return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`unable to read package.json: ${error.message}`);
+    }
+}
+function readVersion(pkg) {
+    if (typeof pkg.version !== 'string' || !pkg.version.trim()) {
+        throw new Error('package.json is missing a valid version field');
+    }
+    parseSemver(pkg.version);
+    return pkg.version;
+}
+function mapConventionalCommits(entries) {
+    return entries.map((entry) => {
+        const raw = entry.message.trim();
+        const match = raw.match(/^(?<type>[a-z]+)(?:\((?<scope>[^)]+)\))?(?<breaking>!)?: (?<description>.+)$/i);
+        const body = entry.body ?? '';
+        const type = match?.groups?.type?.toLowerCase() ?? 'other';
+        const scope = match?.groups?.scope || undefined;
+        const description = match?.groups?.description?.trim() ?? raw;
+        const breaking = match?.groups?.breaking === '!' ||
+            /BREAKING CHANGE:/i.test(raw) ||
+            /BREAKING CHANGE:/i.test(body);
+        return {
+            hash: entry.hash,
+            shortHash: entry.hash.slice(0, 7),
+            raw,
+            description,
+            type,
+            scope,
+            author: entry.author_name,
+            date: entry.date,
+            breaking,
+        };
+    });
+}
+function renderConventionalChangelog(commits) {
+    if (commits.length === 0) {
+        return '- No changes recorded.';
+    }
+    const sections = new Map();
+    for (const section of SECTION_ORDER)
+        sections.set(section, []);
+    for (const commit of commits) {
+        if (commit.breaking) {
+            sections.get('Breaking Changes')?.push(formatCommitLine(commit));
+        }
+        sections.get(sectionForCommit(commit.type))?.push(formatCommitLine(commit));
+    }
+    const lines = [];
+    for (const section of SECTION_ORDER) {
+        const items = sections.get(section) ?? [];
+        if (items.length === 0)
+            continue;
+        lines.push(`### ${section}`, '', ...items, '');
+    }
+    return lines.join('\n').trim() || '- No changes recorded.';
+}
+function sectionForCommit(type) {
+    switch (type) {
+        case 'feat':
+            return 'Features';
+        case 'fix':
+            return 'Fixes';
+        case 'docs':
+            return 'Documentation';
+        case 'perf':
+            return 'Performance';
+        case 'refactor':
+            return 'Refactors';
+        case 'test':
+            return 'Tests';
+        case 'build':
+            return 'Build';
+        case 'ci':
+            return 'CI';
+        case 'chore':
+        case 'style':
+            return 'Chores';
+        case 'revert':
+            return 'Reverts';
+        default:
+            return 'Other';
+    }
+}
+function formatCommitLine(commit) {
+    const scope = commit.scope ? `**${commit.scope}:** ` : '';
+    return `- ${scope}${commit.description} (${commit.shortHash})`;
+}
+function buildUpdatedChangelog(currentChangelog, version, changelogEntry) {
+    const changelog = currentChangelog?.trim().length
+        ? currentChangelog
+        : DEFAULT_CHANGELOG.trimEnd();
+    const releaseSection = `## [${version}] - ${new Date().toISOString().slice(0, 10)}\n\n${changelogEntry.trim()}\n`;
+    const unreleasedHeading = /^## \[Unreleased\].*$/m;
+    const match = unreleasedHeading.exec(changelog);
+    if (!match) {
+        const base = changelog.trimEnd();
+        return `${base}\n\n## [Unreleased]\n\n${releaseSection}\n`;
+    }
+    const headingStart = match.index;
+    const headingEnd = headingStart + match[0].length;
+    const afterHeading = changelog.slice(headingEnd);
+    const nextHeadingRelative = afterHeading.search(/\n## \[/);
+    const sectionEnd = nextHeadingRelative === -1 ? changelog.length : headingEnd + nextHeadingRelative;
+    const before = changelog.slice(0, headingStart);
+    const after = changelog.slice(sectionEnd).replace(/^\r?\n/, '');
+    const freshUnreleased = `${match[0]}\n\n`;
+    const next = `${before}${freshUnreleased}${releaseSection}${after ? `\n${after}` : ''}`;
+    return next.endsWith('\n') ? next : `${next}\n`;
+}
+function runPublish(cwd, distTag) {
+    const args = ['publish'];
+    if (distTag) {
+        args.push('--tag', distTag);
+    }
+    const result = spawnSync('npm', args, {
+        cwd,
+        encoding: 'utf8',
+        shell: process.platform === 'win32',
+        stdio: 'pipe',
+    });
+    if (result.status !== 0) {
+        const details = [result.stderr, result.stdout].filter(Boolean).join('\n').trim();
+        throw new Error(details || `npm publish failed with exit ${result.status ?? 'unknown'}`);
+    }
+}
+function formatPrerelease(target, current) {
+    const base = formatSemver(target);
+    const sameCore = current.major === target.major &&
+        current.minor === target.minor &&
+        current.patch === target.patch;
+    if (!sameCore || !current.prerelease) {
+        return `${base}-0`;
+    }
+    const match = current.prerelease.match(/(?:^|\.)(\d+)$/);
+    const next = match ? Number.parseInt(match[1], 10) + 1 : 0;
+    return `${base}-${next}`;
+}
+function parseReleaseArgs(args) {
+    const [first, ...rest] = args;
+    if (!first) {
+        throw new Error('Usage: /release <major|minor|patch|premajor|preminor|prepatch> [--tag <dist-tag>] [--dry-run] [--skip-changelog] [--skip-tag] [--skip-publish] | /release preview [type] | /release status');
+    }
+    if (first === 'status') {
+        return { mode: 'status' };
+    }
+    if (first === 'preview') {
+        const [maybeType, ...tail] = rest;
+        const type = isReleaseType(maybeType) ? maybeType : 'patch';
+        const optionArgs = isReleaseType(maybeType) ? tail : rest;
+        return {
+            mode: 'preview',
+            options: parseReleaseOptions(type, optionArgs),
+        };
+    }
+    if (!isReleaseType(first)) {
+        throw new Error('Usage: /release <major|minor|patch|premajor|preminor|prepatch> [--tag <dist-tag>] [--dry-run] [--skip-changelog] [--skip-tag] [--skip-publish] | /release preview [type] | /release status');
+    }
+    return {
+        mode: 'release',
+        options: parseReleaseOptions(first, rest),
+    };
+}
+function parseReleaseOptions(type, args) {
+    const options = { type };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        switch (arg) {
+            case '--tag': {
+                const value = args[++index]?.trim();
+                if (!value) {
+                    throw new Error('Usage: /release <type> [--tag <dist-tag>] [--dry-run] [--skip-changelog] [--skip-tag] [--skip-publish]');
+                }
+                options.tag = value;
+                break;
+            }
+            case '--dry-run':
+                options.dryRun = true;
+                break;
+            case '--skip-changelog':
+                options.skipChangelog = true;
+                break;
+            case '--skip-tag':
+                options.skipTag = true;
+                break;
+            case '--skip-publish':
+                options.skipPublish = true;
+                break;
+            default:
+                throw new Error('Usage: /release <type> [--tag <dist-tag>] [--dry-run] [--skip-changelog] [--skip-tag] [--skip-publish]');
+        }
+    }
+    return options;
+}
+function isReleaseType(value) {
+    return Boolean(value && RELEASE_TYPES.includes(value));
+}
+function formatReleaseResult(result) {
+    return [
+        theme.ok(`✔ release prepared: ${result.version}`),
+        `  tag:       ${theme.hl(result.tag)}`,
+        `  published: ${theme.hl(result.published ? 'yes' : 'no')}`,
+        '',
+        theme.brand('Changelog entry'),
+        result.changelog,
+        '',
+    ].join('\n');
+}
+function formatPreview(result) {
+    return [
+        theme.brand('Release preview'),
+        `  version:   ${theme.hl(result.version)}`,
+        `  tag:       ${theme.hl(result.tag)}`,
+        `  published: ${theme.hl('no (dry run)')}`,
+        '',
+        theme.brand('Changelog preview'),
+        result.changelog,
+        '',
+    ].join('\n');
+}
+function formatStatus(snapshot) {
+    return [
+        theme.brand('Release status'),
+        `  cwd:               ${theme.dim(snapshot.cwd)}`,
+        `  version:           ${theme.hl(snapshot.currentVersion)}`,
+        `  latest tag:        ${theme.hl(snapshot.latestTag ?? 'none')}`,
+        `  unreleased commits:${theme.hl(` ${snapshot.commits.length}`)}`,
+        `  working tree:      ${theme.hl(snapshot.dirty ? 'dirty' : 'clean')}`,
+        '',
+        theme.brand('Unreleased changes'),
+        snapshot.unreleasedChanges,
+        '',
+    ].join('\n');
+}

package/dist/commands/repo-cmd.js

@@ -0,0 +1,195 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import simpleGit from 'simple-git';
+import { MultiRepoOrchestrator, } from '../agents/multi-repo.js';
+import { theme } from '../ui/theme.js';
+export const MULTI_REPO_ROOT_ENV = 'ICOPILOT_MULTI_REPO_ROOT';
+export async function repoCommand(args, options) {
+    const rootDir = resolveMultiRepoRoot(options.cwd);
+    const orchestrator = new MultiRepoOrchestrator();
+    orchestrator.loadConfig(rootDir);
+    const [rawSubcommand = 'show', ...rest] = args;
+    const subcommand = rawSubcommand.toLowerCase();
+    try {
+        switch (subcommand) {
+            case 'show':
+            case 'list':
+                return formatRepoList(await orchestrator.getStatus());
+            case 'add':
+                return addRepo(orchestrator, rootDir, rest, options.cwd);
+            case 'remove':
+            case 'delete':
+            case 'rm':
+                return removeRepo(orchestrator, rest);
+            case 'switch':
+                return switchRepo(orchestrator, rootDir, rest, options);
+            case 'status':
+                return formatRepoStatus(await orchestrator.getStatus());
+            case 'search':
+                return searchRepos(orchestrator, rest);
+            default:
+                return repoUsage();
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return theme.err(`repo: ${message}\n`);
+    }
+}
+export function resolveMultiRepoRoot(cwd) {
+    const envRoot = process.env[MULTI_REPO_ROOT_ENV];
+    if (envRoot && fs.existsSync(envRoot)) {
+        return path.resolve(envRoot);
+    }
+    const discovered = findConfigRoot(cwd);
+    return discovered ?? path.resolve(cwd);
+}
+function findConfigRoot(startDir) {
+    let current = path.resolve(startDir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const candidate = path.join(current, '.icopilot', 'repos.yaml');
+        if (fs.existsSync(candidate))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return undefined;
+}
+async function addRepo(orchestrator, rootDir, args, cwd) {
+    const repoPathArg = args[0];
+    if (!repoPathArg)
+        return theme.warn('usage: /repo add <path> [name]\n');
+    const repoPath = path.resolve(cwd, repoPathArg);
+    if (!fs.existsSync(repoPath) || !fs.statSync(repoPath).isDirectory()) {
+        return theme.err(`repo path does not exist: ${repoPath}\n`);
+    }
+    const explicitName = args.slice(1).join(' ').trim();
+    const metadata = await detectRepoMetadata(repoPath);
+    const repos = orchestrator.listRepos();
+    const repo = orchestrator.addRepo({
+        name: explicitName || path.basename(repoPath),
+        path: repoPath,
+        remote: metadata.remote,
+        branch: metadata.branch,
+        role: repos.length === 0 ? 'primary' : 'peer',
+    });
+    process.env[MULTI_REPO_ROOT_ENV] = rootDir;
+    const parts = [`✔ added repo ${theme.hl(repo.name)} ${theme.dim(`→ ${repo.path}`)}`];
+    if (repo.branch)
+        parts.push(theme.dim(`branch=${repo.branch}`));
+    if (repo.remote)
+        parts.push(theme.dim(`remote=${repo.remote}`));
+    return `${parts.join(' ')}\n`;
+}
+function removeRepo(orchestrator, args) {
+    const name = args.join(' ').trim();
+    if (!name)
+        return theme.warn('usage: /repo remove <name>\n');
+    if (!orchestrator.removeRepo(name)) {
+        return theme.warn(`unknown repo: ${name}\n`);
+    }
+    return theme.ok(`✔ removed repo ${name}\n`);
+}
+function switchRepo(orchestrator, rootDir, args, options) {
+    const name = args.join(' ').trim();
+    if (!name)
+        return theme.warn('usage: /repo switch <name>\n');
+    const repo = orchestrator.switchRepo(name);
+    process.env[MULTI_REPO_ROOT_ENV] = rootDir;
+    options.onSwitch?.(repo, rootDir);
+    return theme.ok(`✔ switched repo ${repo.name} ${theme.dim(`→ ${repo.path}`)}\n`);
+}
+async function searchRepos(orchestrator, args) {
+    const query = args.join(' ').trim();
+    if (!query)
+        return theme.warn('usage: /repo search <query>\n');
+    const hits = await orchestrator.searchAcrossRepos(query);
+    if (!hits.length) {
+        return theme.dim(`No matches found across ${orchestrator.listRepos().length} repos.\n`);
+    }
+    return formatRepoSearchResults(query, hits);
+}
+async function detectRepoMetadata(repoPath) {
+    try {
+        const git = simpleGit(repoPath);
+        if (!(await git.checkIsRepo()))
+            return {};
+        const remotes = await git.getRemotes(true);
+        const branch = (await git.revparse(['--abbrev-ref', 'HEAD'])).trim();
+        return {
+            branch: branch || undefined,
+            remote: remotes[0]?.name,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function formatRepoList(status) {
+    if (!status.repos.length) {
+        return `${theme.brand('Repositories')} ${theme.dim(status.rootDir)}\n  ${theme.dim('No repositories configured. Use /repo add <path> [name].')}\n`;
+    }
+    const lines = [`${theme.brand('Repositories')} ${theme.dim(status.rootDir)}`, ''];
+    for (const repo of status.repos) {
+        const marker = repo.name === status.current ? theme.ok('*') : theme.dim('-');
+        const branch = repo.branch || repo.currentBranch;
+        lines.push(`  ${marker} ${theme.hl(repo.name)} ${theme.dim(`(${repo.role})`)} ${theme.dim('→')} ${repo.path}${branch ? theme.dim(` [${branch}]`) : ''}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function formatRepoStatus(status) {
+    if (!status.repos.length) {
+        return `${theme.brand('Repo status')} ${theme.dim(status.rootDir)}\n  ${theme.dim('No repositories configured.')}\n`;
+    }
+    const lines = [
+        `${theme.brand('Repo status')} ${theme.dim(status.rootDir)}`,
+        `  config: ${status.configPath}`,
+        `  current: ${status.current ? theme.hl(status.current) : theme.dim('none')}`,
+        '',
+    ];
+    for (const repo of status.repos) {
+        const health = !repo.exists
+            ? theme.err('missing')
+            : repo.error
+                ? theme.err('error')
+                : repo.git
+                    ? theme.ok(repo.dirty ? 'dirty' : 'clean')
+                    : theme.warn('not-git');
+        const branch = repo.currentBranch || repo.branch || theme.dim('n/a');
+        lines.push(`  ${theme.hl(repo.name)} ${health} ${theme.dim(`(${repo.role})`)}`);
+        lines.push(`    path: ${repo.path}`);
+        lines.push(`    branch: ${branch}`);
+        if (repo.git) {
+            lines.push(`    ahead/behind: ${repo.ahead}/${repo.behind}`);
+        }
+        if (repo.error) {
+            lines.push(`    error: ${repo.error}`);
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function formatRepoSearchResults(query, hits) {
+    const lines = [`${theme.brand('Repo search')} ${theme.dim(`for "${query}"`)}`, ''];
+    for (const hit of hits) {
+        lines.push(`  ${theme.hl(hit.repo)} ${theme.dim('→')} ${hit.file}:${hit.line}`);
+        lines.push(`    ${hit.text}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function repoUsage() {
+    return [
+        'usage: /repo',
+        '       /repo add <path> [name]',
+        '       /repo remove <name>',
+        '       /repo switch <name>',
+        '       /repo status',
+        '       /repo search <query>',
+        '',
+    ].join('\n');
+}

package/dist/commands/route-cmd.js

@@ -0,0 +1,21 @@
+import { PROFILES, toProfile } from '../routing/profiles.js';
+import { getProfile, setProfile } from '../routing/router.js';
+export function routeCommand(arg) {
+    const [subcommand = 'get', profile] = arg.trim().split(/\s+/).filter(Boolean);
+    switch (subcommand.toLowerCase()) {
+        case 'get':
+            return `routing profile: ${getProfile()}\n`;
+        case 'list':
+            return `routing profiles: ${Object.keys(PROFILES).join(', ')}\n`;
+        case 'set': {
+            const next = toProfile(profile);
+            if (!next) {
+                return `unknown routing profile: ${profile || '(missing)'}\n`;
+            }
+            setProfile(next);
+            return `✔ routing profile → ${next}\n`;
+        }
+        default:
+            return 'usage: /route get | /route set <cheap|balanced|strong|fixed> | /route list\n';
+    }
+}