iranti 0.2.2 → 0.2.3

package/dist/scripts/iranti-cli.js

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const promises_1 = __importDefault(require("fs/promises"));
+const https_1 = __importDefault(require("https"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
@@ -14,6 +15,10 @@ const stream_1 = require("stream");
 const net_1 = __importDefault(require("net"));
 const client_1 = require("../src/library/client");
 const apiKeys_1 = require("../src/security/apiKeys");
+const escalationPaths_1 = require("../src/lib/escalationPaths");
+const resolutionist_1 = require("../src/resolutionist");
+const chat_1 = require("../src/chat");
+const backends_1 = require("../src/library/backends");
 const PROVIDER_ENV_KEYS = {
     mock: null,
     ollama: null,
@@ -314,6 +319,13 @@ function formatEnvValue(value) {
         ? `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
         : value;
 }
+function vectorBackendUrl(name, env) {
+    if (name === 'qdrant')
+        return env.IRANTI_QDRANT_URL ?? null;
+    if (name === 'chroma')
+        return env.IRANTI_CHROMA_URL ?? 'http://localhost:8000';
+    return null;
+}
 async function upsertEnvFile(filePath, updates) {
     const existingRaw = fs_1.default.existsSync(filePath) ? await promises_1.default.readFile(filePath, 'utf-8') : '';
     const lines = existingRaw.length > 0 ? existingRaw.split(/\r?\n/) : [];
@@ -1003,6 +1015,337 @@ function summarizeStatus(checks) {
         return 'warn';
     return 'pass';
 }
+function resolveDoctorEnvTarget(args) {
+    const scope = normalizeScope(getFlag(args, 'scope'));
+    const instanceName = getFlag(args, 'instance');
+    const explicitEnv = getFlag(args, 'env');
+    const cwd = process.cwd();
+    if (explicitEnv) {
+        return {
+            envFile: path_1.default.resolve(explicitEnv),
+            envSource: 'explicit-env',
+        };
+    }
+    if (instanceName) {
+        const root = resolveInstallRoot(args, scope);
+        return {
+            envFile: path_1.default.join(root, 'instances', instanceName, '.env'),
+            envSource: `instance:${instanceName}`,
+        };
+    }
+    const repoEnv = path_1.default.join(cwd, '.env');
+    const projectEnv = path_1.default.join(cwd, '.env.iranti');
+    if (fs_1.default.existsSync(repoEnv)) {
+        return { envFile: repoEnv, envSource: 'repo' };
+    }
+    if (fs_1.default.existsSync(projectEnv)) {
+        return { envFile: projectEnv, envSource: 'project-binding' };
+    }
+    return { envFile: null, envSource: 'repo' };
+}
+function resolveUpgradeTarget(raw) {
+    if (!raw)
+        return 'auto';
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'auto' || normalized === 'npm-global' || normalized === 'npm-repo' || normalized === 'python') {
+        return normalized;
+    }
+    throw new Error(`Invalid --target '${raw}'. Use auto, npm-global, npm-repo, or python.`);
+}
+function parseVersion(value) {
+    if (!value)
+        return [0];
+    const match = value.trim().match(/^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!match)
+        return [0];
+    return [
+        Number.parseInt(match[1] ?? '0', 10),
+        Number.parseInt(match[2] ?? '0', 10),
+        Number.parseInt(match[3] ?? '0', 10),
+    ];
+}
+function compareVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    const limit = Math.max(a.length, b.length, 3);
+    for (let i = 0; i < limit; i++) {
+        const av = a[i] ?? 0;
+        const bv = b[i] ?? 0;
+        if (av > bv)
+            return 1;
+        if (av < bv)
+            return -1;
+    }
+    return 0;
+}
+function normalizePathForCompare(value) {
+    return path_1.default.resolve(value).replace(/\\/g, '/').toLowerCase();
+}
+function isPathInside(parentDir, childDir) {
+    const parent = normalizePathForCompare(parentDir);
+    const child = normalizePathForCompare(childDir);
+    return child === parent || child.startsWith(`${parent}/`);
+}
+function resolveSpawnExecutable(executable) {
+    if (process.platform !== 'win32')
+        return executable;
+    if (executable === 'npm')
+        return 'npm.cmd';
+    if (executable === 'npx')
+        return 'npx.cmd';
+    return executable;
+}
+function runCommandCapture(executable, args, cwd) {
+    const proc = (0, child_process_1.spawnSync)(resolveSpawnExecutable(executable), args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return {
+        status: proc.status,
+        stdout: proc.stdout ?? '',
+        stderr: proc.stderr ?? '',
+    };
+}
+function runCommandInteractive(step) {
+    const proc = (0, child_process_1.spawnSync)(resolveSpawnExecutable(step.executable), step.args, {
+        cwd: step.cwd,
+        stdio: 'inherit',
+    });
+    return proc.status;
+}
+function detectPythonLauncher() {
+    const candidates = process.platform === 'win32'
+        ? [
+            { label: 'python', display: 'python -m pip install --upgrade iranti', executable: 'python', args: ['-m', 'pip', 'install', '--upgrade', 'iranti'] },
+            { label: 'py', display: 'py -3 -m pip install --upgrade iranti', executable: 'py', args: ['-3', '-m', 'pip', 'install', '--upgrade', 'iranti'] },
+        ]
+        : [
+            { label: 'python3', display: 'python3 -m pip install --upgrade iranti', executable: 'python3', args: ['-m', 'pip', 'install', '--upgrade', 'iranti'] },
+            { label: 'python', display: 'python -m pip install --upgrade iranti', executable: 'python', args: ['-m', 'pip', 'install', '--upgrade', 'iranti'] },
+        ];
+    for (const candidate of candidates) {
+        const probeArgs = candidate.args[0] === '-3' ? ['-3', '--version'] : ['--version'];
+        const probe = runCommandCapture(candidate.executable, probeArgs);
+        if (probe.status === 0)
+            return candidate;
+    }
+    return null;
+}
+function detectGlobalNpmRoot() {
+    const proc = runCommandCapture('npm', ['root', '-g']);
+    if (proc.status !== 0)
+        return null;
+    const value = proc.stdout.trim();
+    return value ? path_1.default.resolve(value) : null;
+}
+function readJsonFile(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function httpsJson(url, headers = {}) {
+    return new Promise((resolve, reject) => {
+        const request = https_1.default.get(url, { headers }, (response) => {
+            const statusCode = response.statusCode ?? 0;
+            if (statusCode >= 300 && statusCode < 400 && response.headers.location) {
+                response.resume();
+                const redirect = new URL(response.headers.location, url).toString();
+                httpsJson(redirect, headers).then(resolve).catch(reject);
+                return;
+            }
+            if (statusCode < 200 || statusCode >= 300) {
+                response.resume();
+                reject(new Error(`HTTP ${statusCode} from ${url}`));
+                return;
+            }
+            let raw = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => {
+                raw += chunk;
+            });
+            response.on('end', () => {
+                try {
+                    resolve(JSON.parse(raw));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        request.setTimeout(5000, () => {
+            request.destroy(new Error(`Timed out fetching ${url}`));
+        });
+        request.on('error', reject);
+    });
+}
+async function fetchLatestNpmVersion() {
+    try {
+        const payload = await httpsJson('https://registry.npmjs.org/iranti/latest');
+        return typeof payload?.version === 'string' ? payload.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchLatestPypiVersion() {
+    try {
+        const payload = await httpsJson('https://pypi.org/pypi/iranti/json');
+        return typeof payload?.info?.version === 'string' ? payload.info.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+function repoUpgradeCommands(root) {
+    return [
+        { label: 'git pull', display: 'git pull --ff-only', executable: 'git', args: ['pull', '--ff-only'], cwd: root },
+        { label: 'npm install', display: 'npm install', executable: 'npm', args: ['install'], cwd: root },
+        { label: 'npm build', display: 'npm run build', executable: 'npm', args: ['run', 'build'], cwd: root },
+    ];
+}
+function repoIsDirty(root) {
+    const proc = runCommandCapture('git', ['status', '--porcelain'], root);
+    return proc.status === 0 && proc.stdout.trim().length > 0;
+}
+function detectUpgradeContext(args) {
+    const scope = normalizeScope(getFlag(args, 'scope'));
+    const packageRootPath = packageRoot();
+    const runtimeRoot = resolveInstallRoot(args, scope);
+    const runtimeInstalled = fs_1.default.existsSync(path_1.default.join(runtimeRoot, 'install.json'));
+    const repoCheckout = fs_1.default.existsSync(path_1.default.join(packageRootPath, '.git'));
+    const globalNpmRoot = detectGlobalNpmRoot();
+    const globalNpmInstall = globalNpmRoot !== null && isPathInside(globalNpmRoot, packageRootPath);
+    const python = detectPythonLauncher();
+    const availableTargets = [];
+    if (globalNpmInstall)
+        availableTargets.push('npm-global');
+    if (repoCheckout)
+        availableTargets.push('npm-repo');
+    if (python)
+        availableTargets.push('python');
+    return {
+        packageRootPath,
+        currentVersion: getPackageVersion(),
+        runtimeRoot,
+        runtimeInstalled,
+        repoCheckout,
+        globalNpmInstall,
+        globalNpmRoot,
+        python,
+        availableTargets,
+    };
+}
+function chooseUpgradeTarget(requested, context) {
+    if (requested !== 'auto') {
+        if (!context.availableTargets.includes(requested)) {
+            throw new Error(`Requested target '${requested}' is not available in this environment.`);
+        }
+        return requested;
+    }
+    if (context.repoCheckout)
+        return 'npm-repo';
+    if (context.globalNpmInstall)
+        return 'npm-global';
+    if (context.python)
+        return 'python';
+    return null;
+}
+function commandListForTarget(target, context) {
+    if (target === 'npm-repo') {
+        return repoUpgradeCommands(context.packageRootPath);
+    }
+    if (target === 'npm-global') {
+        return [{
+                label: 'npm global',
+                display: 'npm install -g iranti@latest',
+                executable: 'npm',
+                args: ['install', '-g', 'iranti@latest'],
+                cwd: context.packageRootPath,
+            }];
+    }
+    if (!context.python) {
+        throw new Error('Python launcher not found for python upgrade target.');
+    }
+    return [context.python];
+}
+async function refreshInstallMetaVersion(runtimeRoot, version) {
+    const installMetaPath = path_1.default.join(runtimeRoot, 'install.json');
+    const meta = readJsonFile(installMetaPath);
+    if (!meta)
+        return;
+    await writeJson(installMetaPath, {
+        ...meta,
+        version,
+        upgradedAt: new Date().toISOString(),
+    });
+}
+function verifyGlobalNpmInstall() {
+    const proc = runCommandCapture('npm', ['list', '-g', 'iranti', '--depth=0', '--json']);
+    if (proc.status !== 0) {
+        return {
+            status: 'warn',
+            detail: 'npm global upgrade finished, but `npm list -g iranti` did not return cleanly.',
+        };
+    }
+    try {
+        const payload = JSON.parse(proc.stdout);
+        const version = payload?.dependencies?.iranti?.version;
+        return typeof version === 'string'
+            ? { status: 'pass', detail: `npm global install reports iranti@${version}.` }
+            : { status: 'warn', detail: 'npm global upgrade finished, but installed version could not be confirmed.' };
+    }
+    catch {
+        return {
+            status: 'warn',
+            detail: 'npm global upgrade finished, but version verification output was unreadable.',
+        };
+    }
+}
+function verifyPythonInstall(command) {
+    const args = command.executable === 'py' ? ['-3', '-m', 'pip', 'show', 'iranti'] : ['-m', 'pip', 'show', 'iranti'];
+    const proc = runCommandCapture(command.executable, args);
+    if (proc.status !== 0) {
+        return {
+            status: 'warn',
+            detail: 'Python upgrade finished, but `pip show iranti` did not confirm the installed version.',
+        };
+    }
+    const versionLine = proc.stdout.split(/\r?\n/).find((line) => line.toLowerCase().startsWith('version:'));
+    return versionLine
+        ? { status: 'pass', detail: `Python client ${versionLine.trim()}.` }
+        : { status: 'warn', detail: 'Python upgrade finished, but installed version could not be confirmed.' };
+}
+async function executeUpgradeTarget(target, context) {
+    if (target === 'npm-repo' && repoIsDirty(context.packageRootPath)) {
+        throw new Error('Repository worktree is dirty. Commit or stash changes before running `iranti upgrade --target npm-repo --yes`.');
+    }
+    const commands = commandListForTarget(target, context);
+    const steps = [];
+    for (const command of commands) {
+        console.log(`${infoLabel()} ${command.display}`);
+        const status = runCommandInteractive(command);
+        steps.push({ label: command.label, command: command.display });
+        if (status !== 0) {
+            throw new Error(`Upgrade step failed: ${command.display}`);
+        }
+    }
+    const verification = target === 'npm-global'
+        ? verifyGlobalNpmInstall()
+        : target === 'python'
+            ? verifyPythonInstall(commands[0])
+            : { status: 'pass', detail: 'Repository refresh completed and build succeeded.' };
+    if (context.runtimeInstalled && verification.status !== 'fail') {
+        const nextVersion = target === 'python' ? context.currentVersion : (await fetchLatestNpmVersion()) ?? context.currentVersion;
+        await refreshInstallMetaVersion(context.runtimeRoot, nextVersion);
+    }
+    return { target, steps, verification };
+}
 async function listProviderKeysCommand(args) {
     const target = await resolveProviderKeyTarget(args);
     const currentProvider = normalizeProvider(target.env.LLM_PROVIDER ?? 'mock');
@@ -1385,34 +1728,8 @@ async function setupCommand(args) {
     console.log(`  2. iranti doctor --instance ${finalResult.instanceName} --root "${finalResult.root}"`);
 }
 async function doctorCommand(args) {
-    const scope = normalizeScope(getFlag(args, 'scope'));
-    const instanceName = getFlag(args, 'instance');
-    const explicitEnv = getFlag(args, 'env');
     const json = hasFlag(args, 'json');
-    const cwd = process.cwd();
-    let envFile = null;
-    let envSource = 'repo';
-    if (explicitEnv) {
-        envFile = path_1.default.resolve(explicitEnv);
-        envSource = 'explicit-env';
-    }
-    else if (instanceName) {
-        const root = resolveInstallRoot(args, scope);
-        envFile = path_1.default.join(root, 'instances', instanceName, '.env');
-        envSource = `instance:${instanceName}`;
-    }
-    else {
-        const repoEnv = path_1.default.join(cwd, '.env');
-        const projectEnv = path_1.default.join(cwd, '.env.iranti');
-        if (fs_1.default.existsSync(repoEnv)) {
-            envFile = repoEnv;
-            envSource = 'repo';
-        }
-        else if (fs_1.default.existsSync(projectEnv)) {
-            envFile = projectEnv;
-            envSource = 'project-binding';
-        }
-    }
+    const { envFile, envSource } = resolveDoctorEnvTarget(args);
     const checks = [];
     const version = getPackageVersion();
     checks.push({
@@ -1507,6 +1824,46 @@ async function doctorCommand(args) {
             detail: `LLM_PROVIDER=${provider}`,
         });
         checks.push(detectProviderKey(provider, env));
+        try {
+            const backendName = (0, backends_1.resolveVectorBackendName)({
+                vectorBackend: env.IRANTI_VECTOR_BACKEND,
+                qdrantUrl: env.IRANTI_QDRANT_URL,
+                qdrantApiKey: env.IRANTI_QDRANT_API_KEY,
+                qdrantCollection: env.IRANTI_QDRANT_COLLECTION,
+                chromaUrl: env.IRANTI_CHROMA_URL,
+                chromaCollection: env.IRANTI_CHROMA_COLLECTION,
+                chromaTenant: env.IRANTI_CHROMA_TENANT,
+                chromaDatabase: env.IRANTI_CHROMA_DATABASE,
+                chromaToken: env.IRANTI_CHROMA_TOKEN,
+            });
+            const backend = (0, backends_1.createVectorBackend)({
+                vectorBackend: backendName,
+                qdrantUrl: env.IRANTI_QDRANT_URL,
+                qdrantApiKey: env.IRANTI_QDRANT_API_KEY,
+                qdrantCollection: env.IRANTI_QDRANT_COLLECTION,
+                chromaUrl: env.IRANTI_CHROMA_URL,
+                chromaCollection: env.IRANTI_CHROMA_COLLECTION,
+                chromaTenant: env.IRANTI_CHROMA_TENANT,
+                chromaDatabase: env.IRANTI_CHROMA_DATABASE,
+                chromaToken: env.IRANTI_CHROMA_TOKEN,
+            });
+            const reachable = await backend.ping();
+            const url = vectorBackendUrl(backendName, env);
+            checks.push({
+                name: 'vector backend',
+                status: reachable ? 'pass' : 'warn',
+                detail: url
+                    ? `${backendName} (${url}) is ${reachable ? 'reachable' : 'unreachable'}`
+                    : `${backendName} is ${reachable ? 'reachable' : 'unreachable'}`,
+            });
+        }
+        catch (error) {
+            checks.push({
+                name: 'vector backend',
+                status: 'fail',
+                detail: error instanceof Error ? error.message : String(error),
+            });
+        }
     }
     const result = {
         version,
@@ -1608,28 +1965,119 @@ async function statusCommand(args) {
     }
 }
 async function upgradeCommand(args) {
+    const checkOnly = hasFlag(args, 'check');
+    const dryRun = hasFlag(args, 'dry-run');
+    const execute = hasFlag(args, 'yes');
     const json = hasFlag(args, 'json');
-    const version = getPackageVersion();
+    const requestedTarget = resolveUpgradeTarget(getFlag(args, 'target'));
+    const context = detectUpgradeContext(args);
+    const latestNpm = await fetchLatestNpmVersion();
+    const latestPython = await fetchLatestPypiVersion();
+    const chosenTarget = chooseUpgradeTarget(requestedTarget, context);
     const commands = {
         npmGlobal: 'npm install -g iranti@latest',
-        npmRepo: 'git pull && npm install && npm run build',
-        python: 'pip install --upgrade iranti',
+        npmRepo: 'git pull --ff-only && npm install && npm run build',
+        python: context.python?.display ?? 'python -m pip install --upgrade iranti',
     };
+    const updateAvailable = {
+        npm: latestNpm ? compareVersions(latestNpm, context.currentVersion) > 0 : null,
+        python: latestPython ? compareVersions(latestPython, context.currentVersion) > 0 : null,
+    };
+    const plan = chosenTarget ? commandListForTarget(chosenTarget, context) : [];
+    let execution = null;
+    let note = null;
+    if (execute) {
+        if (!chosenTarget) {
+            throw new Error('No executable upgrade path was detected. Use --target npm-global, --target npm-repo, or --target python.');
+        }
+        if (dryRun || checkOnly) {
+            note = 'Execution skipped because --dry-run or --check was provided.';
+        }
+        else if (chosenTarget === 'npm-global' && updateAvailable.npm === false) {
+            note = 'npm global install is already at the latest published version.';
+        }
+        else if (chosenTarget === 'python' && updateAvailable.python === false) {
+            note = 'Python client is already at the latest published version.';
+        }
+        else {
+            execution = await executeUpgradeTarget(chosenTarget, context);
+        }
+    }
+    else if (!checkOnly && !dryRun) {
+        note = 'Run with --yes to execute the selected upgrade path. Use --check to inspect and --dry-run to print exact commands.';
+    }
     if (json) {
         console.log(JSON.stringify({
-            version,
-            note: 'iranti upgrade currently prints recommended upgrade commands. It does not self-update in place yet.',
+            currentVersion: context.currentVersion,
+            latest: {
+                npm: latestNpm,
+                python: latestPython,
+            },
+            install: {
+                packageRoot: context.packageRootPath,
+                runtimeRoot: context.runtimeRoot,
+                runtimeInstalled: context.runtimeInstalled,
+                repoCheckout: context.repoCheckout,
+                globalNpmInstall: context.globalNpmInstall,
+                globalNpmRoot: context.globalNpmRoot,
+                pythonLauncher: context.python?.executable ?? null,
+            },
+            requestedTarget,
+            selectedTarget: chosenTarget,
+            availableTargets: context.availableTargets,
+            updateAvailable,
             commands,
+            plan: plan.map((step) => step.display),
+            action: execute && !dryRun && !checkOnly ? 'upgrade' : checkOnly ? 'check' : dryRun ? 'dry-run' : 'inspect',
+            execution,
+            note,
         }, null, 2));
         return;
     }
     console.log(bold('Iranti upgrade'));
-    console.log(`  current_version  ${version}`);
-    console.log('  note             This command does not self-update yet. Use the appropriate package-manager path below.');
+    console.log(`  current_version  ${context.currentVersion}`);
+    console.log(`  latest_npm       ${latestNpm ?? '(unavailable)'}`);
+    console.log(`  latest_python    ${latestPython ?? '(unavailable)'}`);
+    console.log(`  package_root     ${context.packageRootPath}`);
+    console.log(`  runtime_root     ${context.runtimeRoot}`);
+    console.log(`  repo_checkout    ${context.repoCheckout ? paint('yes', 'green') : paint('no', 'gray')}`);
+    console.log(`  npm_global       ${context.globalNpmInstall ? paint('yes', 'green') : paint('no', 'gray')}`);
+    console.log(`  python           ${context.python?.executable ?? paint('not found', 'yellow')}`);
+    console.log('');
+    if (chosenTarget) {
+        console.log(`  selected_target  ${paint(chosenTarget, 'cyan')}${requestedTarget === 'auto' ? paint(' (auto)', 'gray') : ''}`);
+        console.log('  plan');
+        for (const step of plan) {
+            console.log(`    - ${step.display}`);
+        }
+    }
+    else {
+        console.log(`  selected_target  ${paint('none', 'yellow')}`);
+        console.log('  plan             No executable upgrade path detected automatically.');
+    }
     console.log('');
     console.log(`  npm global       ${commands.npmGlobal}`);
     console.log(`  npm repo         ${commands.npmRepo}`);
     console.log(`  python client    ${commands.python}`);
+    if (execution) {
+        const marker = execution.verification.status === 'pass'
+            ? okLabel('PASS')
+            : execution.verification.status === 'warn'
+                ? warnLabel('WARN')
+                : failLabel('FAIL');
+        console.log('');
+        console.log(`${okLabel()} Upgrade completed for ${execution.target}.`);
+        console.log(`${marker} ${execution.verification.detail}`);
+        const { envFile } = resolveDoctorEnvTarget(args);
+        if (envFile) {
+            console.log(`${infoLabel()} Run \`iranti doctor\` to verify the active environment after the package upgrade.`);
+        }
+        return;
+    }
+    if (note) {
+        console.log('');
+        console.log(`${infoLabel()} ${note}`);
+    }
 }
 async function installCommand(args) {
     const scope = normalizeScope(getFlag(args, 'scope'));
@@ -2066,6 +2514,23 @@ async function authRevokeKeyCommand(args) {
     console.log(`${okLabel()} Revoked API key '${keyId}' for instance '${instanceName}'.`);
     process.exit(0);
 }
+async function resolveCommand(args) {
+    const explicitDir = getFlag(args, 'dir');
+    const escalationDir = explicitDir ? path_1.default.resolve(explicitDir) : (0, escalationPaths_1.getEscalationPaths)().root;
+    await (0, resolutionist_1.resolveInteractive)(escalationDir);
+}
+async function chatCommand(args) {
+    const provider = normalizeProvider(getFlag(args, 'provider'));
+    if (provider && !isSupportedProvider(provider)) {
+        throw new Error(`Unsupported provider '${provider}'.`);
+    }
+    await (0, chat_1.startChatSession)({
+        agentId: getFlag(args, 'agent') ?? 'iranti_chat',
+        provider,
+        model: getFlag(args, 'model'),
+        cwd: process.cwd(),
+    });
+}
 function printHelp() {
     console.log(`Iranti CLI
 
@@ -2097,10 +2562,12 @@ Configuration:
 Project-level:
   iranti project init [path] --instance <name> [--api-key <token>] [--agent-id <id>] [--force]
 
-Diagnostics:
-  iranti doctor [--instance <name>] [--scope user|system] [--env <file>] [--json]
-  iranti status [--scope user|system] [--json]
-  iranti upgrade [--json]
+  Diagnostics:
+    iranti doctor [--instance <name>] [--scope user|system] [--env <file>] [--json]
+    iranti status [--scope user|system] [--json]
+    iranti upgrade [--check] [--dry-run] [--yes] [--target auto|npm-global|npm-repo|python] [--json]
+    iranti chat [--agent <agent-id>] [--provider <provider>] [--model <model>]
+    iranti resolve [--dir <escalation-dir>]
 
 Integrations:
   iranti mcp [--help]
@@ -2199,6 +2666,14 @@ async function main() {
         await upgradeCommand(args);
         return;
     }
+    if (args.command === 'chat') {
+        await chatCommand(args);
+        return;
+    }
+    if (args.command === 'resolve') {
+        await resolveCommand(args);
+        return;
+    }
     if (args.command === 'mcp') {
         await handoffToScript('iranti-mcp', process.argv.slice(3));
         return;

package/dist/scripts/iranti-mcp.js

@@ -144,7 +144,7 @@ async function main() {
     await ensureDefaultAgent(iranti);
     const server = new mcp_js_1.McpServer({
         name: 'iranti-mcp',
-        version: '0.2.2',
+        version: '0.2.3',
     });
     server.registerTool('iranti_handshake', {
         description: `Initialize or refresh an agent's working-memory brief for the current task.