kie-ai-cli 1.0.0

package/dist/code.js

@@ -0,0 +1,937 @@
+import fs from 'fs';
+import path from 'path';
+const DEFAULT_EXCLUDED_DIRS = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    '.cursor',
+    '.vscode',
+]);
+function isTextLike(content) {
+    return !content.includes('\u0000');
+}
+async function safeReadText(filePath, maxChars) {
+    try {
+        const raw = await fs.promises.readFile(filePath, 'utf-8');
+        if (!isTextLike(raw))
+            return '[binary file skipped]';
+        if (raw.length <= maxChars)
+            return raw;
+        return `${raw.slice(0, maxChars)}\n\n... [truncated: ${raw.length - maxChars} chars omitted]`;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return `[read failed: ${msg}]`;
+    }
+}
+async function walkTree(root, options) {
+    const lines = [];
+    const excluded = options.excludedDirs ?? DEFAULT_EXCLUDED_DIRS;
+    const visit = async (current, relative) => {
+        if (lines.length >= options.maxEntries)
+            return;
+        let entries = [];
+        try {
+            entries = await fs.promises.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (lines.length >= options.maxEntries)
+                return;
+            const rel = relative ? path.posix.join(relative, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                if (excluded.has(entry.name))
+                    continue;
+                lines.push(`${rel}/`);
+                await visit(path.join(current, entry.name), rel);
+            }
+            else {
+                lines.push(rel);
+            }
+        }
+    };
+    await visit(root, '');
+    return lines;
+}
+async function walkFiles(root, maxEntries) {
+    const files = [];
+    const visit = async (current, relative) => {
+        if (files.length >= maxEntries)
+            return;
+        let entries = [];
+        try {
+            entries = await fs.promises.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (files.length >= maxEntries)
+                return;
+            const rel = relative ? path.posix.join(relative, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                if (DEFAULT_EXCLUDED_DIRS.has(entry.name))
+                    continue;
+                await visit(path.join(current, entry.name), rel);
+            }
+            else {
+                files.push(rel);
+            }
+        }
+    };
+    await visit(root, '');
+    return files;
+}
+export async function buildCodeContext(options) {
+    const files = await Promise.all(options.includeFiles.map(async (requestedPath) => {
+        const resolvedPath = path.resolve(options.cwd, requestedPath);
+        const relPath = path.relative(options.cwd, resolvedPath) || requestedPath;
+        const content = await safeReadText(resolvedPath, options.maxFileChars);
+        return {
+            requestedPath,
+            resolvedPath: relPath,
+            content,
+        };
+    }));
+    const tree = options.includeTree
+        ? (await walkTree(options.cwd, { maxEntries: options.treeMaxEntries })).join('\n')
+        : null;
+    return { tree, files };
+}
+export function getCodeWorkspaceConfigPath(cwd) {
+    return path.join(cwd, '.kie', 'code.json');
+}
+function safeWeight(value, fallback = 1) {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        return fallback;
+    return Math.max(0.05, Number(n.toFixed(3)));
+}
+export function buildDefaultRoutingConfig(defaultModel = 'claude-opus-4-7') {
+    return {
+        strategy: 'weighted-random',
+        phases: {
+            plan: [{ model: defaultModel, weight: 1 }],
+            execute: [{ model: defaultModel, weight: 1 }],
+            fix: [{ model: defaultModel, weight: 1 }],
+        },
+    };
+}
+function normalizeRoutingConfig(input, fallbackModel) {
+    const defaultConfig = buildDefaultRoutingConfig(fallbackModel);
+    const strategy = input?.strategy === 'argmax' || input?.strategy === 'weighted-random'
+        ? input.strategy
+        : defaultConfig.strategy;
+    const normalizePhase = (phase) => {
+        const raw = input?.phases?.[phase];
+        if (!Array.isArray(raw) || raw.length === 0)
+            return defaultConfig.phases[phase];
+        const cleaned = raw
+            .map((item) => ({
+            model: typeof item?.model === 'string' ? item.model.trim() : '',
+            weight: safeWeight(item?.weight, 1),
+        }))
+            .filter((item) => item.model.length > 0);
+        return cleaned.length > 0 ? cleaned : defaultConfig.phases[phase];
+    };
+    return {
+        strategy,
+        phases: {
+            plan: normalizePhase('plan'),
+            execute: normalizePhase('execute'),
+            fix: normalizePhase('fix'),
+        },
+    };
+}
+export async function initCodeWorkspace(cwd, defaults) {
+    const configPath = getCodeWorkspaceConfigPath(cwd);
+    const dir = path.dirname(configPath);
+    const config = {
+        version: 1,
+        createdAt: new Date().toISOString(),
+        root: cwd,
+        includeTree: defaults?.includeTree ?? true,
+        treeLimit: defaults?.treeLimit ?? 120,
+        fileMaxChars: defaults?.fileMaxChars ?? 8000,
+        defaultModel: defaults?.defaultModel,
+        defaultRoute: defaults?.defaultRoute ?? 'auto',
+        routing: normalizeRoutingConfig(defaults?.routing, defaults?.defaultModel || 'claude-opus-4-7'),
+    };
+    const exists = await fs.promises.stat(configPath).then(() => true).catch(() => false);
+    if (exists) {
+        const loaded = await loadCodeWorkspaceConfig(cwd);
+        return { created: false, configPath, config: loaded ?? config };
+    }
+    await fs.promises.mkdir(dir, { recursive: true });
+    await fs.promises.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    return { created: true, configPath, config };
+}
+export async function loadCodeWorkspaceConfig(cwd) {
+    const configPath = getCodeWorkspaceConfigPath(cwd);
+    try {
+        const raw = await fs.promises.readFile(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return {
+            version: 1,
+            createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : new Date().toISOString(),
+            root: typeof parsed.root === 'string' ? parsed.root : cwd,
+            includeTree: typeof parsed.includeTree === 'boolean' ? parsed.includeTree : true,
+            treeLimit: typeof parsed.treeLimit === 'number' && parsed.treeLimit > 0 ? parsed.treeLimit : 120,
+            fileMaxChars: typeof parsed.fileMaxChars === 'number' && parsed.fileMaxChars > 0
+                ? parsed.fileMaxChars
+                : 8000,
+            defaultModel: typeof parsed.defaultModel === 'string' ? parsed.defaultModel : undefined,
+            defaultRoute: resolveCodeRoute(parsed.defaultRoute),
+            routing: normalizeRoutingConfig(parsed.routing, typeof parsed.defaultModel === 'string' ? parsed.defaultModel : 'claude-opus-4-7'),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveCodeWorkspaceConfig(cwd, config) {
+    const filePath = getCodeWorkspaceConfigPath(cwd);
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    const next = {
+        ...config,
+        defaultRoute: resolveCodeRoute(config.defaultRoute),
+        routing: normalizeRoutingConfig(config.routing, config.defaultModel || 'claude-opus-4-7'),
+    };
+    await fs.promises.writeFile(filePath, JSON.stringify(next, null, 2), 'utf-8');
+}
+export function resolveCodeRoute(input) {
+    const normalized = (input || '').trim().toLowerCase();
+    if (normalized === 'quality' || normalized === 'balanced' || normalized === 'fast') {
+        return normalized;
+    }
+    return 'auto';
+}
+function chooseExistingModel(candidates, fallback) {
+    for (const model of candidates) {
+        if (model)
+            return model;
+    }
+    return fallback;
+}
+export function pickModelByRoute(route, fallbackModel, phase) {
+    if (route === 'quality') {
+        return chooseExistingModel(['claude-opus-4-7', 'claude-opus-4-6', fallbackModel], fallbackModel);
+    }
+    if (route === 'balanced') {
+        return chooseExistingModel(['claude-sonnet-4-6', 'claude-sonnet-4-5', fallbackModel], fallbackModel);
+    }
+    if (route === 'fast') {
+        return chooseExistingModel(['claude-haiku-4-5', fallbackModel], fallbackModel);
+    }
+    if (phase === 'fix') {
+        return chooseExistingModel(['claude-sonnet-4-6', 'claude-sonnet-4-5', fallbackModel], fallbackModel);
+    }
+    if (phase === 'execute') {
+        return chooseExistingModel(['claude-opus-4-7', 'claude-sonnet-4-6', fallbackModel], fallbackModel);
+    }
+    return chooseExistingModel(['claude-opus-4-7', fallbackModel], fallbackModel);
+}
+export function getCodeModelMetricsPath(cwd) {
+    return path.join(cwd, '.kie', 'model-metrics.json');
+}
+export async function loadCodeModelMetrics(cwd) {
+    const filePath = getCodeModelMetricsPath(cwd);
+    try {
+        const raw = await fs.promises.readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || !parsed.metrics) {
+            return { version: 1, updatedAt: new Date().toISOString(), metrics: {} };
+        }
+        return {
+            version: 1,
+            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
+            metrics: parsed.metrics,
+        };
+    }
+    catch {
+        return { version: 1, updatedAt: new Date().toISOString(), metrics: {} };
+    }
+}
+export async function saveCodeModelMetrics(cwd, data) {
+    const filePath = getCodeModelMetricsPath(cwd);
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(filePath, JSON.stringify({ ...data, updatedAt: new Date().toISOString() }, null, 2), 'utf-8');
+}
+export function recordCodeModelMetric(data, model, success, latencyMs) {
+    const current = data.metrics[model] || {
+        model,
+        runs: 0,
+        success: 0,
+        fail: 0,
+        avgLatencyMs: 0,
+    };
+    current.runs += 1;
+    if (success)
+        current.success += 1;
+    else
+        current.fail += 1;
+    const boundedLatency = Math.max(1, Math.round(latencyMs));
+    current.avgLatencyMs =
+        current.runs === 1
+            ? boundedLatency
+            : Math.round((current.avgLatencyMs * (current.runs - 1) + boundedLatency) / current.runs);
+    data.metrics[model] = current;
+    data.updatedAt = new Date().toISOString();
+}
+function computeModelScore(entry, metric) {
+    const baseWeight = safeWeight(entry.weight, 1);
+    if (!metric || metric.runs === 0)
+        return baseWeight;
+    const successRate = metric.success / Math.max(1, metric.runs);
+    const successFactor = 0.7 + successRate * 0.6;
+    const latencyFactor = metric.avgLatencyMs <= 2500 ? 1 : Math.max(0.6, 2500 / metric.avgLatencyMs);
+    return Number((baseWeight * successFactor * latencyFactor).toFixed(4));
+}
+function weightedPick(items) {
+    const total = items.reduce((sum, item) => sum + Math.max(0, item.score), 0);
+    if (total <= 0)
+        return items[0]?.model || '';
+    const target = Math.random() * total;
+    let acc = 0;
+    for (const item of items) {
+        acc += Math.max(0, item.score);
+        if (target <= acc)
+            return item.model;
+    }
+    return items[items.length - 1]?.model || '';
+}
+export function selectModelFromRouting(route, fallbackModel, phase, routing, metrics) {
+    if (route !== 'auto') {
+        const picked = pickModelByRoute(route, fallbackModel, phase);
+        return { model: picked, scored: [{ model: picked, score: 1, baseWeight: 1 }] };
+    }
+    const pool = routing.phases[phase] || [];
+    const scored = pool
+        .map((entry) => ({
+        model: entry.model,
+        score: computeModelScore(entry, metrics.metrics[entry.model]),
+        baseWeight: safeWeight(entry.weight, 1),
+    }))
+        .filter((item) => item.model);
+    if (scored.length === 0) {
+        return { model: fallbackModel, scored: [{ model: fallbackModel, score: 1, baseWeight: 1 }] };
+    }
+    const model = routing.strategy === 'argmax'
+        ? [...scored].sort((a, b) => b.score - a.score)[0].model
+        : weightedPick(scored);
+    return { model, scored };
+}
+export function upsertWeightedModel(routing, phase, model, weight) {
+    const trimmedModel = model.trim();
+    const next = normalizeRoutingConfig(routing, trimmedModel || 'claude-opus-4-7');
+    const list = next.phases[phase].filter((item) => item.model !== trimmedModel);
+    list.push({ model: trimmedModel, weight: safeWeight(weight, 1) });
+    next.phases[phase] = list;
+    return next;
+}
+export function removeWeightedModel(routing, phase, model) {
+    const next = normalizeRoutingConfig(routing, 'claude-opus-4-7');
+    next.phases[phase] = next.phases[phase].filter((item) => item.model !== model.trim());
+    if (next.phases[phase].length === 0) {
+        next.phases[phase] = [{ model: 'claude-opus-4-7', weight: 1 }];
+    }
+    return next;
+}
+export function getCodeWorkspaceProfilePath(cwd) {
+    return path.join(cwd, '.kie', 'workspace.json');
+}
+async function detectPackageManager(cwd) {
+    const tryStat = async (p) => { try {
+        await fs.promises.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    } };
+    if (await tryStat(path.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (await tryStat(path.join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (await tryStat(path.join(cwd, 'bun.lockb')) || await tryStat(path.join(cwd, 'bun.lock')))
+        return 'bun';
+    if (await tryStat(path.join(cwd, 'package-lock.json')))
+        return 'npm';
+    return 'unknown';
+}
+async function readPackageJsonInfo(cwd) {
+    try {
+        const raw = await fs.promises.readFile(path.join(cwd, 'package.json'), 'utf-8');
+        const p = JSON.parse(raw);
+        const deps = Object.keys(p.dependencies || {});
+        const devDeps = Object.keys(p.devDependencies || {});
+        return {
+            name: p.name || null,
+            description: p.description || null,
+            scripts: Object.keys(p.scripts || {}),
+            scriptDetails: (p.scripts || {}),
+            dependencies: deps,
+            devDependencies: devDeps,
+            allDeps: new Set([...deps, ...devDeps]),
+            main: p.main || null,
+            bin: typeof p.bin === 'string' ? [p.bin] : Object.values(p.bin || {}),
+            engines: (p.engines || {}),
+        };
+    }
+    catch {
+        return { name: null, description: null, scripts: [], scriptDetails: {}, dependencies: [], devDependencies: [], allDeps: new Set(), main: null, bin: [], engines: {} };
+    }
+}
+function detectFrameworks(allDeps, topFiles) {
+    const r = [];
+    const check = (dep, label) => { if (allDeps.has(dep))
+        r.push(label); };
+    check('next', 'Next.js');
+    check('nuxt', 'Nuxt');
+    check('react', 'React');
+    check('vue', 'Vue');
+    check('@angular/core', 'Angular');
+    check('svelte', 'Svelte');
+    check('express', 'Express');
+    check('fastify', 'Fastify');
+    check('koa', 'Koa');
+    check('@nestjs/core', 'NestJS');
+    check('electron', 'Electron');
+    check('prisma', 'Prisma');
+    check('@prisma/client', 'Prisma');
+    check('mongoose', 'Mongoose');
+    check('typeorm', 'TypeORM');
+    check('sequelize', 'Sequelize');
+    check('tailwindcss', 'Tailwind CSS');
+    check('styled-components', 'Styled Components');
+    check('redux', 'Redux');
+    check('@reduxjs/toolkit', 'Redux Toolkit');
+    check('zustand', 'Zustand');
+    check('mobx', 'MobX');
+    check('socket.io', 'Socket.IO');
+    check('graphql', 'GraphQL');
+    check('trpc', 'tRPC');
+    check('@trpc/server', 'tRPC');
+    check('commander', 'Commander');
+    check('inquirer', 'Inquirer');
+    check('three', 'Three.js');
+    check('d3', 'D3.js');
+    if (topFiles.has('manage.py'))
+        r.push('Django');
+    if (topFiles.has('go.mod'))
+        r.push('Go Module');
+    if (topFiles.has('Cargo.toml'))
+        r.push('Rust/Cargo');
+    if (topFiles.has('pyproject.toml') || topFiles.has('setup.py') || topFiles.has('requirements.txt'))
+        r.push('Python');
+    return [...new Set(r)];
+}
+function detectTestFramework(allDeps, scriptDetails) {
+    if (allDeps.has('vitest'))
+        return 'Vitest';
+    if (allDeps.has('jest'))
+        return 'Jest';
+    if (allDeps.has('mocha'))
+        return 'Mocha';
+    if (allDeps.has('@playwright/test') || allDeps.has('playwright'))
+        return 'Playwright';
+    if (allDeps.has('cypress'))
+        return 'Cypress';
+    if (allDeps.has('ava'))
+        return 'Ava';
+    const ts = scriptDetails['test'] || '';
+    if (ts.includes('vitest'))
+        return 'Vitest';
+    if (ts.includes('jest'))
+        return 'Jest';
+    if (ts.includes('mocha'))
+        return 'Mocha';
+    if (ts.includes('pytest'))
+        return 'Pytest';
+    return null;
+}
+function detectBuildTool(allDeps, topFiles) {
+    if (allDeps.has('vite'))
+        return 'Vite';
+    if (allDeps.has('webpack'))
+        return 'Webpack';
+    if (allDeps.has('esbuild'))
+        return 'esbuild';
+    if (allDeps.has('rollup'))
+        return 'Rollup';
+    if (allDeps.has('parcel'))
+        return 'Parcel';
+    if (topFiles.has('turbo.json'))
+        return 'Turborepo';
+    if (topFiles.has('tsconfig.json') && allDeps.has('typescript'))
+        return 'tsc';
+    if (topFiles.has('Makefile'))
+        return 'Make';
+    return null;
+}
+const KNOWN_CONFIG_FILES = new Set([
+    'tsconfig.json', 'jsconfig.json',
+    '.eslintrc', '.eslintrc.js', '.eslintrc.json', '.eslintrc.yml', 'eslint.config.js', 'eslint.config.mjs',
+    '.prettierrc', '.prettierrc.js', '.prettierrc.json', 'prettier.config.js',
+    'vite.config.ts', 'vite.config.js', 'webpack.config.js', 'webpack.config.ts',
+    'next.config.js', 'next.config.mjs', 'next.config.ts',
+    'tailwind.config.js', 'tailwind.config.ts', 'postcss.config.js',
+    '.babelrc', 'babel.config.js',
+    'docker-compose.yml', 'docker-compose.yaml', 'Dockerfile',
+    '.env', '.env.local', '.env.example',
+    'jest.config.js', 'jest.config.ts', 'vitest.config.ts', 'vitest.config.js',
+    'turbo.json', '.editorconfig', '.nvmrc', '.node-version',
+    'Makefile', 'Procfile', 'vercel.json', 'netlify.toml',
+    'go.mod', 'Cargo.toml', 'pyproject.toml', 'requirements.txt',
+]);
+const KNOWN_KEY_FILES = new Set([
+    'README.md', 'readme.md', 'README.txt', 'CHANGELOG.md',
+    'CONTRIBUTING.md', 'LICENSE', 'LICENSE.md',
+]);
+function detectConfigFiles(entries) {
+    return entries.filter((e) => !e.isDirectory() && KNOWN_CONFIG_FILES.has(e.name)).map((e) => e.name).sort();
+}
+function detectKeyFiles(entries) {
+    return entries.filter((e) => !e.isDirectory() && KNOWN_KEY_FILES.has(e.name)).map((e) => e.name);
+}
+function detectEntryPoints(pkg, topFileSet) {
+    const entries = [];
+    if (pkg.main)
+        entries.push(pkg.main);
+    entries.push(...pkg.bin);
+    for (const f of ['src/index.ts', 'src/index.js', 'src/main.ts', 'src/main.js', 'src/app.ts', 'src/app.js', 'index.ts', 'index.js', 'app.ts', 'app.js', 'server.ts', 'server.js', 'main.go', 'main.py', 'app.py']) {
+        if (topFileSet.has(f))
+            entries.push(f);
+    }
+    return [...new Set(entries)].slice(0, 8);
+}
+async function detectGitBranch(cwd) {
+    try {
+        const head = await fs.promises.readFile(path.join(cwd, '.git', 'HEAD'), 'utf-8');
+        const match = head.trim().match(/^ref:\s*refs\/heads\/(.+)$/);
+        return match ? match[1] : head.trim().slice(0, 12);
+    }
+    catch {
+        return null;
+    }
+}
+async function detectNodeVersion(cwd) {
+    for (const f of ['.nvmrc', '.node-version']) {
+        try {
+            const v = (await fs.promises.readFile(path.join(cwd, f), 'utf-8')).trim();
+            if (v)
+                return v;
+        }
+        catch { }
+    }
+    return null;
+}
+function summarizeLanguages(files) {
+    const counters = new Map();
+    for (const file of files) {
+        const ext = path.extname(file).toLowerCase() || '(none)';
+        counters.set(ext, (counters.get(ext) || 0) + 1);
+    }
+    return [...counters.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([ext, count]) => ({ ext, count }));
+}
+export async function scanWorkspaceProfile(cwd, maxEntries = 800) {
+    let entries = [];
+    try {
+        entries = await fs.promises.readdir(cwd, { withFileTypes: true });
+    }
+    catch { }
+    const topLevelDirs = entries
+        .filter((entry) => entry.isDirectory() && !DEFAULT_EXCLUDED_DIRS.has(entry.name))
+        .map((entry) => entry.name)
+        .sort()
+        .slice(0, 30);
+    const topFileSet = new Set(entries.filter((e) => !e.isDirectory()).map((e) => e.name));
+    // Also check src/ for entry points
+    try {
+        const srcEntries = await fs.promises.readdir(path.join(cwd, 'src'), { withFileTypes: true });
+        for (const e of srcEntries) {
+            if (!e.isDirectory())
+                topFileSet.add(`src/${e.name}`);
+        }
+    }
+    catch { }
+    const files = await walkFiles(cwd, maxEntries);
+    const pkg = await readPackageJsonInfo(cwd);
+    const frameworks = detectFrameworks(pkg.allDeps, topFileSet);
+    return {
+        version: 2,
+        createdAt: new Date().toISOString(),
+        root: cwd,
+        packageManager: await detectPackageManager(cwd),
+        scripts: pkg.scripts,
+        topLevelDirs,
+        languageStats: summarizeLanguages(files),
+        projectName: pkg.name,
+        projectDescription: pkg.description,
+        dependencies: pkg.dependencies.slice(0, 30),
+        devDependencies: pkg.devDependencies.slice(0, 20),
+        frameworks,
+        configFiles: detectConfigFiles(entries),
+        testFramework: detectTestFramework(pkg.allDeps, pkg.scriptDetails),
+        buildTool: detectBuildTool(pkg.allDeps, topFileSet),
+        entryPoints: detectEntryPoints(pkg, topFileSet),
+        gitBranch: await detectGitBranch(cwd),
+        totalFiles: files.length,
+        keyFiles: detectKeyFiles(entries),
+        nodeVersion: pkg.engines['node'] || await detectNodeVersion(cwd),
+    };
+}
+export async function initCodeWorkspaceProfile(cwd, maxEntries = 500) {
+    const profilePath = getCodeWorkspaceProfilePath(cwd);
+    await fs.promises.mkdir(path.dirname(profilePath), { recursive: true });
+    const profile = await scanWorkspaceProfile(cwd, maxEntries);
+    await fs.promises.writeFile(profilePath, JSON.stringify(profile, null, 2), 'utf-8');
+    return { profilePath, profile };
+}
+export async function loadCodeWorkspaceProfile(cwd) {
+    const profilePath = getCodeWorkspaceProfilePath(cwd);
+    try {
+        const raw = await fs.promises.readFile(profilePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildCodeSystemPrompt(profile) {
+    const base = [
+        '你是 Kie — 一个驻留在终端中的顶级 AI 软件工程师。',
+        '你精通全栈开发、系统架构和 DevOps，能独立完成从需求分析到生产部署的完整工程链路。',
+        '',
+        '【核心原则】',
+        '1. 精准理解意图：用户的需求可能模糊，你必须推断最合理的解读，而不是追问显而易见的细节。',
+        '2. 最小改动原则：只修改完成任务必须改动的部分，不要进行未被要求的重构、美化或"顺便"优化。',
+        '3. 防御性编码：所有代码必须处理边界情况和异常，类型安全优先。',
+        '4. 输出极度精简：不要复述需求、不要输出"好的我来帮你"之类的废话。直接给方案和代码。',
+        '5. 中文交流：全程使用专业中文，技术术语保留英文原词（如 async、middleware、hook）。',
+    ];
+    if (profile) {
+        base.push('', '【当前工作区信息】');
+        if (profile.projectName)
+            base.push(`- 项目: ${profile.projectName}${profile.projectDescription ? ` — ${profile.projectDescription}` : ''}`);
+        base.push(`- 包管理器: ${profile.packageManager}`);
+        if (profile.nodeVersion)
+            base.push(`- Node 版本: ${profile.nodeVersion}`);
+        if (profile.gitBranch)
+            base.push(`- Git 分支: ${profile.gitBranch}`);
+        if (profile.frameworks?.length)
+            base.push(`- 技术栈: ${profile.frameworks.join(', ')}`);
+        if (profile.buildTool)
+            base.push(`- 构建工具: ${profile.buildTool}`);
+        if (profile.testFramework)
+            base.push(`- 测试框架: ${profile.testFramework}`);
+        base.push(`- 可用 scripts: ${profile.scripts.join(', ') || '(无)'}`);
+        base.push(`- 主要语言: ${profile.languageStats.slice(0, 5).map(l => `${l.ext}(${l.count})`).join(', ') || '(未知)'}`);
+        base.push(`- 顶层目录: ${profile.topLevelDirs.join(', ') || '(未知)'}`);
+        if (profile.entryPoints?.length)
+            base.push(`- 入口文件: ${profile.entryPoints.join(', ')}`);
+        if (profile.configFiles?.length)
+            base.push(`- 配置文件: ${profile.configFiles.join(', ')}`);
+        if (profile.dependencies?.length)
+            base.push(`- 核心依赖: ${profile.dependencies.slice(0, 15).join(', ')}${(profile.dependencies.length || 0) > 15 ? ` (+${profile.dependencies.length - 15})` : ''}`);
+        if (profile.totalFiles)
+            base.push(`- 文件总数: ${profile.totalFiles}`);
+    }
+    return base.join('\n');
+}
+export function buildCodeAgentSystemPrompt(profile) {
+    return [
+        buildCodeSystemPrompt(profile),
+        '',
+        '═══════════════════════════════════════════',
+        '          AGENT 自治执行模式',
+        '═══════════════════════════════════════════',
+        '',
+        '你被授权在用户的 Windows 机器上自主执行命令。',
+        '你的工作方式是：探查 → 规划 → 执行 → 验证，循环直至任务完成。',
+        '',
+        '【决策框架】',
+        '第一轮：必须先探查项目现状（dir / type 目标文件），绝对禁止在未读取文件的情况下直接修改代码。',
+        '后续轮：根据上一轮命令的实际输出来决定下一步，而不是臆测结果。',
+        '最终轮：执行验证命令（构建/测试），确认无误后标记 done=true。',
+        '',
+        '【命令规范 — Windows 环境】',
+        '✅ 允许: dir, type, node, npm, npx, pnpm, git, powershell 内置命令',
+        '❌ 禁止: cat, ls, grep, rm, touch, sed, awk（这些不是 Windows 命令）',
+        '⚠️ 路径用反斜杠 \\\\，引号用双引号 ""',
+        '',
+        '【文件编辑工具箱】',
+        '修改文件时绝对禁止输出完整文件内容！请使用以下方法之一：',
+        '',
+        '方法A — Node.js 精确替换（推荐）:',
+        'node -e "let f=require(\'fs\');let s=f.readFileSync(\'文件路径\',\'utf8\');s=s.replace(\'旧内容\',\'新内容\');f.writeFileSync(\'文件路径\',s)"',
+        '',
+        '方法B — Node.js 行级插入/替换:',
+        'node -e "let f=require(\'fs\');let lines=f.readFileSync(\'文件路径\',\'utf8\').split(\'\\n\');lines.splice(行号,删除行数,\'新行内容\');f.writeFileSync(\'文件路径\',lines.join(\'\\n\'))"',
+        '',
+        '方法C — 创建新文件（仅小文件 <30 行时可用）:',
+        'node -e "require(\'fs\').writeFileSync(\'文件路径\', `完整内容`)"',
+        '',
+        '【错误自愈协议】',
+        '当命令执行失败时：',
+        '1. 先分析错误信息的根因（不要猜测）',
+        '2. 用 type 或 dir 确认文件/目录的实际状态',
+        '3. 针对性修复，一次只改一处',
+        '4. 再次运行验证命令确认修复成功',
+        '',
+        '【输出截断声明】',
+        '注意：超长的命令输出（如 type 大文件）会被 CLI 自动截断，你看到的可能只有头部和尾部各一段。',
+        '如果需要查看文件特定区域，请使用: node -e "console.log(require(\'fs\').readFileSync(\'文件\',\'utf8\').split(\'\\n\').slice(起始行,结束行).join(\'\\n\'))"',
+        '',
+        '【强制输出格式】',
+        '你的每一次回复必须严格使用以下 XML 结构（标签外不允许有任何文字）：',
+        '',
+        '<assistant_reply>',
+        '1-3 句话，简要说明你在这一轮做了什么/要做什么。',
+        '</assistant_reply>',
+        '<commands>',
+        '每行一条命令（最多 3 条）',
+        '如果任务已完成或仅需回答问题，此处留空',
+        '</commands>',
+        '<done>false</done>',
+        '',
+        '【done 判定标准】',
+        'false = 任务尚未完成，或需要更多验证',
+        'true  = 用户要求已 100% 实现 + 验证通过 + 无残留问题',
+    ].join('\n');
+}
+export function buildCodeUserPrompt(userTask, context, profile) {
+    const sections = [];
+    sections.push(`【用户任务】\n${userTask.trim()}`);
+    if (profile) {
+        const lines = [];
+        if (profile.projectName)
+            lines.push(`项目: ${profile.projectName}${profile.projectDescription ? ` — ${profile.projectDescription}` : ''}`);
+        lines.push(`packageManager: ${profile.packageManager}`);
+        if (profile.gitBranch)
+            lines.push(`branch: ${profile.gitBranch}`);
+        if (profile.frameworks?.length)
+            lines.push(`技术栈: ${profile.frameworks.join(', ')}`);
+        if (profile.buildTool)
+            lines.push(`构建: ${profile.buildTool}`);
+        if (profile.testFramework)
+            lines.push(`测试: ${profile.testFramework}`);
+        lines.push(`scripts: ${profile.scripts.join(', ') || '(none)'}`);
+        lines.push(`topLevelDirs: ${profile.topLevelDirs.join(', ') || '(none)'}`);
+        lines.push(`languages: ${profile.languageStats.map((l) => `${l.ext}:${l.count}`).join(', ') || '(none)'}`);
+        if (profile.entryPoints?.length)
+            lines.push(`入口: ${profile.entryPoints.join(', ')}`);
+        if (profile.configFiles?.length)
+            lines.push(`配置: ${profile.configFiles.join(', ')}`);
+        if (profile.dependencies?.length)
+            lines.push(`dependencies: ${profile.dependencies.join(', ')}`);
+        if (profile.devDependencies?.length)
+            lines.push(`devDependencies: ${profile.devDependencies.join(', ')}`);
+        if (profile.totalFiles)
+            lines.push(`文件总数: ${profile.totalFiles}`);
+        sections.push(`【工作区画像】\n${lines.join('\n')}`);
+    }
+    if (context.tree) {
+        sections.push(`【项目结构（截断）】\n${context.tree}`);
+    }
+    if (context.files.length > 0) {
+        const filesText = context.files
+            .map((file) => `### ${file.resolvedPath}\n\`\`\`\n${file.content}\n\`\`\``)
+            .join('\n\n');
+        sections.push(`【用户指定文件内容】\n${filesText}`);
+    }
+    sections.push([
+        '【输出要求】',
+        '- 先给出“实现方案（MVP）”',
+        '- 再给出“建议修改文件清单”',
+        '- 最后给出“验证命令与预期结果”',
+    ].join('\n'));
+    return sections.join('\n\n');
+}
+function readTag(text, tag) {
+    const re = new RegExp(`<${tag}>[\\s\\S]*?<\\/${tag}>`, 'i');
+    const matched = text.match(re);
+    if (!matched)
+        return '';
+    return matched[0]
+        .replace(new RegExp(`^<${tag}>`, 'i'), '')
+        .replace(new RegExp(`<\\/${tag}>$`, 'i'), '')
+        .trim();
+}
+function extractCommandsFromFencedBlocks(text) {
+    const commands = [];
+    const blockRe = /```(?:bash|sh|shell|powershell|pwsh|cmd)?\s*([\s\S]*?)```/gi;
+    let match = blockRe.exec(text);
+    while (match) {
+        const lines = match[1]
+            .split('\n')
+            .map((line) => line.trim())
+            .map((line) => line.replace(/^\$\s*/, '').replace(/^PS>\s*/i, '').trim())
+            .filter((line) => line.length > 0 && !line.startsWith('#'));
+        commands.push(...lines);
+        match = blockRe.exec(text);
+    }
+    return commands;
+}
+function extractCommandsFromLooseLines(text) {
+    const likely = /^(?:\$|PS>|>)?\s*(npm|pnpm|yarn|npx|node|git|ls|dir|type|cat|python|pytest|go|cargo|dotnet|mvn|gradle|bun|tsc|powershell|mkdir|echo|copy|pip|poetry|make|cmake)\b/i;
+    const numbered = /^(?:\d+[.)\s]\s*|[-*]\s+)(?:\$|PS>|>)?\s*(npm|pnpm|yarn|npx|node|git|dir|type|tsc|powershell|mkdir|echo)\b/i;
+    return text
+        .split('\n')
+        .map((line) => line.trim())
+        .map((line) => line.replace(/^\d+[.)\s]\s*/, '').replace(/^[-*]\s+/, '').replace(/^\$\s*/, '').replace(/^PS>\s*/i, '').replace(/^>\s*/, '').trim())
+        .filter((line) => likely.test(line) || numbered.test(line));
+}
+export function parseAgentResponse(text) {
+    const thought = readTag(text, 'thought');
+    const reply = readTag(text, 'assistant_reply') || text.trim();
+    const commandsBlock = readTag(text, 'commands');
+    const doneRaw = readTag(text, 'done').toLowerCase();
+    let commands = commandsBlock
+        .split('\n')
+        .map((line) => line.trim())
+        .map((line) => line.replace(/^[-*]\s*/, '').replace(/^\$\s*/, '').trim())
+        .filter(Boolean);
+    if (commands.length === 0) {
+        commands = extractCommandsFromFencedBlocks(text);
+    }
+    if (commands.length === 0) {
+        commands = extractCommandsFromLooseLines(text);
+    }
+    commands = commands.slice(0, 3);
+    let done = doneRaw === 'true';
+    if (!doneRaw) {
+        const normalized = text.toLowerCase();
+        if (commands.length === 0 && (normalized.includes('已完成') || normalized.includes('done'))) {
+            done = true;
+        }
+    }
+    return { thought, reply, commands, done };
+}
+/**
+ * 裁剪对话历史，防止 token 爆炸。
+ * 保留第一条用户消息（原始意图）和最近 keepRecent 条消息，
+ * 中间部分用一条摘要消息替代。仅用于构建 API 请求，不修改原始数组。
+ */
+export function trimConversation(conversation, maxMessages = 24, keepRecent = 10) {
+    if (conversation.length <= maxMessages)
+        return conversation;
+    const firstUserIdx = conversation.findIndex((m) => m.role === 'user');
+    const firstUser = firstUserIdx >= 0 ? conversation[firstUserIdx] : null;
+    const recent = conversation.slice(-keepRecent);
+    const trimmedCount = conversation.length - keepRecent - (firstUser ? 1 : 0);
+    const contextNote = {
+        role: 'user',
+        content: `[System] 为控制 token 用量，已省略中间 ${trimmedCount} 条对话记录。请基于最近的上下文继续推进任务。`,
+    };
+    const result = [];
+    if (firstUser)
+        result.push(firstUser);
+    result.push(contextNote);
+    result.push(...recent);
+    return result;
+}
+/** 截断超长命令输出，保留头尾各 headLines/tailLines 行 */
+export function truncateCommandOutput(output, maxLines = 80, headLines = 40, tailLines = 30) {
+    const lines = output.split('\n');
+    if (lines.length <= maxLines)
+        return output;
+    const omitted = lines.length - headLines - tailLines;
+    return [
+        ...lines.slice(0, headLines),
+        `\n... [已省略中间 ${omitted} 行，共 ${lines.length} 行] ...\n`,
+        ...lines.slice(-tailLines),
+    ].join('\n');
+}
+const DANGEROUS_PATTERNS = [
+    /\brm\s+-rf\s+\/\b/i,
+    /\brm\s+-rf\s+\*\b/i,
+    /\bshutdown\b/i,
+    /\breboot\b/i,
+    /\bmkfs\b/i,
+    /\bformat\b/i,
+    /\bdel\s+\/f\s+\/s\s+\/q\b/i,
+    /\bpoweroff\b/i,
+];
+export function isDangerousCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return true;
+    return DANGEROUS_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+async function getCodeSessionsDir(cwd) {
+    const dir = path.join(cwd, '.kie', 'sessions');
+    await fs.promises.mkdir(dir, { recursive: true });
+    return dir;
+}
+async function getCodeSessionPath(cwd, sessionId) {
+    const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return path.join(await getCodeSessionsDir(cwd), `${safe}.json`);
+}
+async function getSessionIndexPath(cwd) {
+    return path.join(await getCodeSessionsDir(cwd), 'sessions-index.json');
+}
+export async function loadSessionIndex(cwd) {
+    const indexPath = await getSessionIndexPath(cwd);
+    try {
+        const raw = await fs.promises.readFile(indexPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveSessionIndex(cwd, index) {
+    const indexPath = await getSessionIndexPath(cwd);
+    await fs.promises.writeFile(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+}
+export function createCodeSessionId() {
+    return `code-${Date.now()}`;
+}
+export async function saveCodeSession(cwd, state) {
+    const filePath = await getCodeSessionPath(cwd, state.id);
+    await fs.promises.writeFile(filePath, JSON.stringify(state, null, 2), 'utf-8');
+    const index = await loadSessionIndex(cwd);
+    index[state.id] = {
+        id: state.id,
+        updatedAt: state.updatedAt || new Date().toISOString(),
+        messageCount: Array.isArray(state.conversation) ? state.conversation.length : 0,
+    };
+    await saveSessionIndex(cwd, index);
+}
+export async function loadCodeSession(cwd, sessionId) {
+    const filePath = await getCodeSessionPath(cwd, sessionId);
+    try {
+        const raw = await fs.promises.readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        return {
+            id: parsed.id || sessionId,
+            updatedAt: parsed.updatedAt || new Date().toISOString(),
+            conversation: Array.isArray(parsed.conversation) ? parsed.conversation : [],
+            extraFiles: Array.isArray(parsed.extraFiles) ? parsed.extraFiles : [],
+            model: typeof parsed.model === 'string' ? parsed.model : 'claude-opus-4-7',
+            route: resolveCodeRoute(parsed.route),
+            autoApprove: Boolean(parsed.autoApprove),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function listCodeSessions(cwd) {
+    const index = await loadSessionIndex(cwd);
+    return Object.values(index).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}