tripo-cli 0.1.0 → 0.2.1

package/dist/src/ai/plan-card.js

@@ -1,79 +0,0 @@
-/**
- * The plan card: one shared "here is what I will do and what it costs"
- * confirmation format used by both the wizard (zero-LLM) and the expert
- * conversation mode. Decisions come from the knowledge base either way.
- */
-import pc from 'picocolors';
-import { t } from '../i18n.js';
-import { getScenario } from '../knowledge/scenarios.js';
-/** Cost-impact annotations derived from the parameter set. */
-export function costNotes(card) {
-    const notes = [];
-    const params = card.genParams;
-    if (params.texture === false) {
-        notes.push(t({ zh: '白模生成:不消耗贴图积分', en: 'bare geometry: no texture credits' }));
-    }
-    if (params.texture_quality === 'detailed' || params.texture_quality === 'extreme') {
-        notes.push(t({ zh: `贴图质量 ${params.texture_quality}:价签更高`, en: `texture_quality ${params.texture_quality}: higher price tier` }));
-    }
-    if (params.geometry_quality === 'detailed') {
-        notes.push(t({ zh: 'geometry detailed(Ultra):加收 HD credit', en: 'geometry detailed (Ultra): extra HD credit' }));
-    }
-    if (params.quad === true) {
-        notes.push(t({ zh: 'quad 四边面:价签更高,输出 FBX', en: 'quad topology: higher price tier, FBX output' }));
-    }
-    if (params.generate_parts === true) {
-        notes.push(t({ zh: '分件生成:价签更高,出裸几何', en: 'part generation: higher price tier, bare geometry' }));
-    }
-    for (const step of card.chain) {
-        if (step.step === 'convert' && Object.keys(step.args).length > 1) {
-            notes.push(t({ zh: 'convert 非默认参数:按 complex 价签计费', en: 'non-default convert options bill as complex convert' }));
-        }
-        if (step.step === 'retarget') {
-            const count = Array.isArray(step.args.animations) ? step.args.animations.length : 1;
-            notes.push(t({ zh: `retarget ${count} 条动画:按条计费`, en: `retarget ${count} animation(s): billed per animation` }));
-        }
-    }
-    return notes;
-}
-/** Render the card for terminal display (stderr). */
-export function renderPlanCard(card) {
-    const scenario = card.scenario ? getScenario(card.scenario) : undefined;
-    const lines = [];
-    const title = t({ zh: '方案卡', en: 'Plan' });
-    lines.push(pc.bold(`── ${title} ──────────────────────────`));
-    lines.push(`${t({ zh: '输入', en: 'input' })}: ${card.inputSummary}`);
-    if (scenario)
-        lines.push(`${t({ zh: '场景', en: 'scenario' })}: ${scenario.id} (${t(scenario.label)})`);
-    if (card.model) {
-        lines.push(`${t({ zh: '模型', en: 'model' })}: ${card.model}${card.modelReason ? pc.dim(` — ${card.modelReason}`) : ''}`);
-    }
-    const params = Object.entries(card.genParams);
-    if (params.length > 0) {
-        lines.push(`${t({ zh: '参数', en: 'params' })}: ${params.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(' ')}`);
-    }
-    if (card.chain.length > 0) {
-        const chainStr = card.chain
-            .map((s) => (Object.keys(s.args).length > 0 ? `${s.step}(${Object.entries(s.args).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(',')})` : s.step))
-            .join(' → ');
-        lines.push(`${t({ zh: '加工链', en: 'chain' })}: ${chainStr}`);
-    }
-    if (card.deliverables.length > 0) {
-        lines.push(`${t({ zh: '交付物', en: 'deliverables' })}: ${card.deliverables.join(', ')}`);
-    }
-    const cost = costNotes(card);
-    if (cost.length > 0) {
-        lines.push(`${t({ zh: '成本影响', en: 'cost impact' })}:`);
-        for (const note of cost)
-            lines.push(`  · ${note}`);
-    }
-    for (const note of card.notes)
-        lines.push(pc.dim(`  ${note}`));
-    if (card.expertNotes && card.expertNotes.length > 0) {
-        lines.push(`${t({ zh: '专家意见', en: 'expert notes' })}:`);
-        for (const note of card.expertNotes)
-            lines.push(`  · ${note}`);
-    }
-    lines.push(pc.bold('──────────────────────────────────'));
-    return lines.join('\n');
-}

package/dist/src/ai/wizard.js

@@ -1,104 +0,0 @@
-/**
- * Wizard mode (zero-LLM): 3–4 multiple-choice questions drive the same
- * knowledge-base decision tree that experts use. Every user gets 80% of the
- * intelligence with no LLM configured.
- */
-import * as p from '@clack/prompts';
-import { CliError, UsageError } from '../core/errors.js';
-import { isInteractive } from '../core/output.js';
-import { t, tList } from '../i18n.js';
-import { EXIT } from '../knowledge/error-catalog.js';
-import { getScenario, SCENARIOS } from '../knowledge/scenarios.js';
-export async function runWizard(initialPrompt) {
-    if (!isInteractive()) {
-        throw new UsageError(t({
-            zh: '向导需要交互终端;无头环境请直接用 tripo make --for <场景> 或配置 LLM 后用 tripo ai --yes',
-            en: 'the wizard needs an interactive terminal; headless callers should use "tripo make --for <scenario>" instead',
-        }));
-    }
-    p.intro('tripo ai');
-    let prompt = initialPrompt?.trim() ?? '';
-    if (!prompt) {
-        const answer = await p.text({
-            message: t({ zh: '想做个什么?一句话描述(或图片路径)', en: 'What do you want to make? one sentence (or an image path)' }),
-            validate: (v) => (v && v.trim().length > 0 ? undefined : t({ zh: '说点什么吧', en: 'say something' })),
-        });
-        if (p.isCancel(answer))
-            throw new CliError('cancelled', EXIT.FATAL);
-        prompt = answer.trim();
-    }
-    const scenarioAnswer = await p.select({
-        message: t({ zh: '用在什么地方?', en: 'What is it for?' }),
-        options: SCENARIOS.map((s) => ({ value: s.id, label: `${t(s.label)} — ${t(s.description)}` })),
-    });
-    if (p.isCancel(scenarioAnswer))
-        throw new CliError('cancelled', EXIT.FATAL);
-    const scenario = getScenario(scenarioAnswer);
-    let engine;
-    if (scenarioAnswer === 'game-mobile' || scenarioAnswer === 'game-pc') {
-        const engineAnswer = await p.select({
-            message: t({ zh: '目标引擎/软件?', en: 'Target engine/software?' }),
-            options: [
-                { value: 'unity', label: 'Unity' },
-                { value: 'unreal', label: 'Unreal' },
-                { value: 'blender', label: 'Blender' },
-                { value: 'any', label: t({ zh: '不确定/通用', en: 'not sure / generic' }) },
-            ],
-        });
-        if (p.isCancel(engineAnswer))
-            throw new CliError('cancelled', EXIT.FATAL);
-        engine = engineAnswer;
-    }
-    let animations = false;
-    if (scenarioAnswer !== 'print' && scenarioAnswer !== 'film') {
-        const animAnswer = await p.confirm({
-            message: t({ zh: '需要骨骼/动画吗?', en: 'Do you need a skeleton / animations?' }),
-            initialValue: scenarioAnswer === 'anim',
-        });
-        if (p.isCancel(animAnswer))
-            throw new CliError('cancelled', EXIT.FATAL);
-        animations = animAnswer;
-    }
-    const { chain, notes } = adjustChain(scenario.id, engine, animations);
-    const card = {
-        inputSummary: prompt,
-        scenario: scenario.id,
-        model: scenario.model,
-        modelReason: t({ zh: '场景预设', en: 'scenario preset' }),
-        genParams: scenario.genParams,
-        chain,
-        deliverables: scenario.deliverables,
-        notes: [...tList(scenario.notes), ...notes],
-    };
-    return { card, options: { prompt, scenario: scenario.id, chain } };
-}
-/** Engine/animation adjustments on top of the scenario chain. */
-export function adjustChain(scenarioId, engine, animations) {
-    const scenario = getScenario(scenarioId);
-    let chain = scenario.chain.map((s) => ({ step: s.step, args: { ...s.args } }));
-    const notes = [];
-    if (animations && !chain.some((s) => s.step === 'rig')) {
-        const rigArgs = { model: 'rig-v2.0', out_format: 'fbx' };
-        if (engine === 'unity') {
-            rigArgs.spec = 'mixamo';
-            notes.push(t({ zh: 'Unity Humanoid → spec=mixamo', en: 'Unity Humanoid → spec=mixamo' }));
-        }
-        chain = [
-            ...chain.filter((s) => s.step !== 'convert'),
-            { step: 'rig-check', args: {} },
-            { step: 'rig', args: rigArgs },
-            { step: 'retarget', args: { animations: ['preset:idle', 'preset:walk'], out_format: 'fbx' } },
-        ];
-        notes.push(t({ zh: '动画链输出 FBX(骨骼+动画)', en: 'animation chain outputs FBX (skeleton + animations)' }));
-    }
-    if (engine && !animations) {
-        const convert = chain.find((s) => s.step === 'convert');
-        if (convert && convert.args.format === 'FBX') {
-            if (engine === 'blender')
-                convert.args.fbx_preset = 'blender';
-            if (engine === 'unreal' || engine === 'unity')
-                convert.args.export_orientation = '+x';
-        }
-    }
-    return { chain, notes };
-}

package/dist/src/cli.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import { runCli } from './program.js';
-process.on('SIGINT', () => {
-    process.stderr.write('\n');
-    process.exit(130);
-});
-void runCli(process.argv);

package/dist/src/commands/account.js

@@ -1,27 +0,0 @@
-/** `tripo balance` / `tripo usage` — account visibility. */
-import { TripoClient } from '../core/client.js';
-import { emitResult } from '../core/output.js';
-import { t } from '../i18n.js';
-export function registerAccountCommands(program) {
-    program
-        .command('balance')
-        .description('show available and frozen credits')
-        .action(async () => {
-        const data = await new TripoClient().getBalance();
-        emitResult(data, t({
-            zh: `余额 ${data.balance} 积分(冻结 ${data.frozen})`,
-            en: `balance: ${data.balance} credits (${data.frozen} frozen)`,
-        }));
-    });
-    program
-        .command('usage')
-        .description('recent task credit usage')
-        .option('--limit <n>', 'max rows to show', (v) => Number(v), 20)
-        .action(async (opts) => {
-        const items = (await new TripoClient().getUsage()).slice(0, opts.limit);
-        const human = items
-            .map((i) => `${(i.created_at ?? '').slice(0, 19).padEnd(20)} ${i.type.padEnd(24)} ${String(i.credits_consumed ?? 0).padStart(6)} cr  ${i.task_id}`)
-            .join('\n');
-        emitResult(items, human || t({ zh: '暂无用量记录', en: 'no usage yet' }));
-    });
-}

package/dist/src/commands/ai.js

@@ -1,113 +0,0 @@
-/**
- * `tripo ai` — dual mode:
- *   wizard (default without an LLM): knowledge-base decision-tree Q&A
- *   conversation (with an LLM configured): producer + specialist agents
- * Both produce the same plan card; confirmed plans execute through the same
- * deterministic engine as `tripo make`.
- */
-import * as p from '@clack/prompts';
-import { resolveReference } from '../config/history.js';
-import { CliError } from '../core/errors.js';
-import { isInteractive, isYes, log, warn } from '../core/output.js';
-import { t } from '../i18n.js';
-import { EXIT } from '../knowledge/error-catalog.js';
-import { executeMake, planMake } from '../pipeline/make.js';
-import { renderPlanCard } from '../ai/plan-card.js';
-import { resolveLlmConfig } from '../ai/llm.js';
-import { buildExpertPlan } from '../ai/experts.js';
-import { runWizard } from '../ai/wizard.js';
-import { emitMakeOutcome } from './make.js';
-import { newClient, withTaskOptions } from './shared.js';
-export function registerAiCommand(program) {
-    const cmd = program
-        .command('ai')
-        .description('describe what you want in natural language; experts plan it, you confirm, it runs')
-        .argument('[request...]', 'e.g. "给我的手游做一个低模骑士,要跑步动画"')
-        .option('--wizard', 'force wizard mode even when an LLM is configured');
-    withTaskOptions(cmd);
-    cmd.action(async (request, flags) => {
-        const text = expandHistoryRefs(request.join(' ').trim());
-        const llm = resolveLlmConfig();
-        let card;
-        let makeOptions;
-        if (llm && !flags.wizard && text) {
-            log(t({ zh: `对话模式(${llm.model})…`, en: `conversation mode (${llm.model})…` }));
-            try {
-                const plan = await buildExpertPlan(text, isInteractive() ? askUser : undefined);
-                card = plan.card;
-                makeOptions = {
-                    inputs: [plan.prompt],
-                    scenario: plan.scenarioId,
-                    chain: plan.chain,
-                    params: plan.params,
-                    name: flags.name,
-                    outDir: flags.out,
-                    notify: flags.notify,
-                    timeoutMs: flags.timeout ? flags.timeout * 1000 : undefined,
-                };
-            }
-            catch (err) {
-                warn(t({
-                    zh: `LLM 编排失败(${err instanceof Error ? err.message : err}),回落到向导模式`,
-                    en: `LLM planning failed (${err instanceof Error ? err.message : err}); falling back to the wizard`,
-                }));
-                const wizard = await runWizard(text);
-                card = wizard.card;
-                makeOptions = wizardToOptions(wizard.options, flags);
-            }
-        }
-        else {
-            if (llm === undefined && text && !isInteractive()) {
-                throw new CliError(t({
-                    zh: '无 LLM 配置时 tripo ai 需要交互终端;无头环境请用 tripo make --for <场景>(或配置 llm.base_url/llm.model)',
-                    en: 'without an LLM, "tripo ai" needs an interactive terminal; headless callers should use "tripo make --for <scenario>" (or configure llm.base_url/llm.model)',
-                }), EXIT.USAGE);
-            }
-            const wizard = await runWizard(text || undefined);
-            card = wizard.card;
-            makeOptions = wizardToOptions(wizard.options, flags);
-        }
-        process.stderr.write(renderPlanCard(card) + '\n');
-        if (!isYes()) {
-            const go = await p.confirm({ message: t({ zh: '按方案执行?', en: 'Run this plan?' }) });
-            if (p.isCancel(go) || !go) {
-                log(t({ zh: '已取消,未消耗积分', en: 'cancelled; no credits spent' }));
-                return;
-            }
-        }
-        const client = newClient();
-        const plan = await planMake(client, makeOptions);
-        const outcome = await executeMake(client, plan, makeOptions);
-        emitMakeOutcome({ results: [outcome.primary], chainResults: outcome.chainResults, stoppedEarly: outcome.stoppedEarly });
-    });
-}
-function wizardToOptions(options, flags) {
-    return {
-        inputs: [options.prompt],
-        scenario: options.scenario,
-        chain: options.chain,
-        params: flags.param,
-        name: flags.name,
-        outDir: flags.out,
-        notify: flags.notify,
-        timeoutMs: flags.timeout ? flags.timeout * 1000 : undefined,
-    };
-}
-async function askUser(question) {
-    const answer = await p.text({ message: question });
-    if (p.isCancel(answer))
-        return undefined;
-    return answer;
-}
-/** Replace @task-name references in a prompt with their task ids. */
-export function expandHistoryRefs(text) {
-    return text.replace(/@[\w\u4e00-\u9fff-]+/g, (ref) => {
-        try {
-            const entry = resolveReference(ref);
-            return entry ? entry.task_id : ref;
-        }
-        catch {
-            return ref; // ambiguity is reported when the value is actually used
-        }
-    });
-}

package/dist/src/commands/batch.js

@@ -1,148 +0,0 @@
-/**
- * `tripo batch run <manifest.yaml>` — bulk production with concurrency,
- * retries, and resumable state (skip jobs already succeeded on re-run).
- *
- * Manifest:
- *   concurrency: 2
- *   defaults: { for: game-mobile, then: "texture,convert:fbx", out: ./assets }
- *   jobs:
- *     - input: "a sword"
- *     - input: cat.png
- *       for: print
- *     - inputs: [hero-front.png, hero-back.png]
- *       name: hero
- */
-import { readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { parse as parseYaml } from 'yaml';
-import { UsageError } from '../core/errors.js';
-import { emitResult, errorLine, log, success } from '../core/output.js';
-import { t } from '../i18n.js';
-import { parseThenExpression } from '../knowledge/chains.js';
-import { executeMake, planMake } from '../pipeline/make.js';
-import { newClient } from './shared.js';
-export function registerBatchCommand(program) {
-    const batch = program.command('batch').description('bulk pipelines from a YAML manifest');
-    batch
-        .command('run <manifest>')
-        .description('run all jobs (resumable: finished jobs are skipped on re-run)')
-        .option('--concurrency <n>', 'parallel jobs (default from manifest or 2)', (v) => Number(v))
-        .option('--retries <n>', 'retries per failed job', (v) => Number(v), 1)
-        .option('--fresh', 'ignore previous state and re-run everything')
-        .action(async (manifestPath, opts) => {
-        const absPath = resolve(manifestPath);
-        const manifest = loadManifest(absPath);
-        const statePath = `${absPath}.state.json`;
-        const state = opts.fresh ? { jobs: {} } : loadState(statePath);
-        const jobs = manifest.jobs.map((job, index) => ({
-            key: job.name ?? `job-${index + 1}`,
-            spec: { ...manifest.defaults, ...job },
-        }));
-        // Duplicate names would corrupt state bookkeeping — fail fast.
-        const seen = new Set();
-        for (const { key } of jobs) {
-            if (seen.has(key))
-                throw new UsageError(`duplicate job name "${key}" in manifest`);
-            seen.add(key);
-        }
-        const concurrency = Math.max(1, opts.concurrency ?? manifest.concurrency ?? 2);
-        const queue = jobs.filter(({ key }) => state.jobs[key]?.status !== 'success');
-        const skipped = jobs.length - queue.length;
-        if (skipped > 0) {
-            log(t({ zh: `跳过 ${skipped} 个已完成任务(断点续跑)`, en: `skipping ${skipped} already-finished job(s) (resume)` }));
-        }
-        log(t({ zh: `批量执行 ${queue.length} 个任务,并发 ${concurrency}`, en: `running ${queue.length} job(s), concurrency ${concurrency}` }));
-        const client = newClient();
-        let cursor = 0;
-        const runNext = async () => {
-            for (;;) {
-                const item = queue[cursor++];
-                if (!item)
-                    return;
-                const jobState = state.jobs[item.key] ?? { status: 'pending', attempts: 0 };
-                state.jobs[item.key] = jobState;
-                const maxAttempts = 1 + opts.retries;
-                for (let attempt = jobState.attempts + 1; attempt <= maxAttempts; attempt++) {
-                    jobState.attempts = attempt;
-                    try {
-                        const outcome = await runJob(client, item.key, item.spec);
-                        jobState.status = 'success';
-                        jobState.task_id = outcome.taskId;
-                        jobState.output_dir = outcome.outputDir;
-                        delete jobState.error;
-                        success(`[${item.key}] done${outcome.outputDir ? ` → ${outcome.outputDir}` : ''}`);
-                        break;
-                    }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err);
-                        jobState.status = 'failed';
-                        jobState.error = message;
-                        errorLine(`[${item.key}] attempt ${attempt}/${maxAttempts} failed: ${message}`);
-                    }
-                    finally {
-                        saveState(statePath, state);
-                    }
-                }
-            }
-        };
-        await Promise.all(Array.from({ length: Math.min(concurrency, queue.length) }, runNext));
-        const summary = {
-            total: jobs.length,
-            success: Object.values(state.jobs).filter((j) => j.status === 'success').length,
-            failed: Object.values(state.jobs).filter((j) => j.status === 'failed').length,
-            state_file: statePath,
-            jobs: state.jobs,
-        };
-        const failed = summary.failed;
-        emitResult(summary, t({
-            zh: `批量完成: 成功 ${summary.success}/${summary.total}${failed ? `,失败 ${failed}(重跑同一命令续跑)` : ''}`,
-            en: `batch finished: ${summary.success}/${summary.total} succeeded${failed ? `, ${failed} failed (re-run the same command to resume)` : ''}`,
-        }));
-        if (failed > 0)
-            process.exitCode = 6;
-    });
-}
-async function runJob(client, key, spec) {
-    const inputs = spec.inputs ?? (spec.input !== undefined ? [spec.input] : []);
-    if (inputs.length === 0)
-        throw new UsageError(`job "${key}" has no input`);
-    const chain = spec.then ? parseThenExpression(spec.then) : undefined;
-    const options = {
-        inputs,
-        scenario: spec.for,
-        chain,
-        model: spec.model,
-        params: spec.params ?? {},
-        name: spec.name ?? key,
-        outDir: spec.out,
-    };
-    const plan = await planMake(client, options);
-    const outcome = await executeMake(client, plan, options);
-    const finalResult = outcome.chainResults[outcome.chainResults.length - 1] ?? outcome.primary;
-    return { taskId: finalResult.task_id, outputDir: finalResult.output_dir ?? outcome.primary.output_dir };
-}
-function loadManifest(path) {
-    let raw;
-    try {
-        raw = readFileSync(path, 'utf8');
-    }
-    catch {
-        throw new UsageError(`manifest not found: ${path}`);
-    }
-    const doc = parseYaml(raw);
-    if (!doc || !Array.isArray(doc.jobs) || doc.jobs.length === 0) {
-        throw new UsageError('manifest must contain a non-empty "jobs" list');
-    }
-    return doc;
-}
-function loadState(path) {
-    try {
-        return JSON.parse(readFileSync(path, 'utf8'));
-    }
-    catch {
-        return { jobs: {} };
-    }
-}
-function saveState(path, state) {
-    writeFileSync(path, JSON.stringify(state, null, 2) + '\n');
-}

package/dist/src/commands/completion.js

@@ -1,84 +0,0 @@
-/** `tripo completion <shell>` — static shell completion scripts. */
-import { UsageError } from '../core/errors.js';
-const COMMANDS = [
-    'login', 'logout', 'whoami', 'balance', 'usage', 'topup',
-    'make', 'view', 'redo', 'ai',
-    'generate', 'model', 'anim', 'mesh', 'task', 'files', 'batch', 'history',
-    'config', 'doctor', 'docs', 'completion', 'mcp',
-];
-const SUBS = {
-    generate: ['text-to-model', 'image-to-model', 'multiview-to-model', 'text-to-image', 'image-to-image', 'image-to-multiview', 'edit-multiview', 'image-to-splat'],
-    model: ['refine', 'texture', 'stylize', 'convert', 'import'],
-    anim: ['check', 'rig', 'retarget'],
-    mesh: ['segment', 'complete', 'decimate', 'smartsegment'],
-    task: ['get', 'list', 'watch'],
-    files: ['upload'],
-    batch: ['run'],
-    config: ['list', 'set', 'unset', 'context'],
-};
-export function registerCompletionCommand(program) {
-    program
-        .command('completion <shell>')
-        .description('print a completion script (bash|zsh|fish); e.g. tripo completion zsh >> ~/.zshrc')
-        .action((shell) => {
-        switch (shell) {
-            case 'bash':
-                process.stdout.write(bashScript());
-                break;
-            case 'zsh':
-                process.stdout.write(zshScript());
-                break;
-            case 'fish':
-                process.stdout.write(fishScript());
-                break;
-            default:
-                throw new UsageError('supported shells: bash, zsh, fish');
-        }
-    });
-}
-function bashScript() {
-    const cases = Object.entries(SUBS)
-        .map(([cmd, subs]) => `    ${cmd}) COMPREPLY=($(compgen -W "${subs.join(' ')}" -- "$cur"));;`)
-        .join('\n');
-    return `# tripo bash completion
-_tripo_completions() {
-  local cur prev
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  prev="\${COMP_WORDS[1]}"
-  if [ "$COMP_CWORD" -eq 1 ]; then
-    COMPREPLY=($(compgen -W "${COMMANDS.join(' ')}" -- "$cur"))
-    return
-  fi
-  case "$prev" in
-${cases}
-  esac
-}
-complete -F _tripo_completions tripo
-`;
-}
-function zshScript() {
-    return `# tripo zsh completion
-autoload -Uz compinit && compinit
-_tripo() {
-  local -a cmds
-  cmds=(${COMMANDS.join(' ')})
-  if (( CURRENT == 2 )); then
-    compadd -a cmds
-  else
-    case $words[2] in
-${Object.entries(SUBS)
-        .map(([cmd, subs]) => `      ${cmd}) compadd ${subs.join(' ')};;`)
-        .join('\n')}
-    esac
-  fi
-}
-compdef _tripo tripo
-`;
-}
-function fishScript() {
-    const lines = [
-        `complete -c tripo -f -n '__fish_use_subcommand' -a '${COMMANDS.join(' ')}'`,
-        ...Object.entries(SUBS).map(([cmd, subs]) => `complete -c tripo -f -n '__fish_seen_subcommand_from ${cmd}' -a '${subs.join(' ')}'`),
-    ];
-    return lines.join('\n') + '\n';
-}

package/dist/src/commands/config-cmd.js

@@ -1,84 +0,0 @@
-/** `tripo config` — global config + directory context management. */
-import { loadConfig, maskKey, saveConfig } from '../config/config.js';
-import { findContextFile, loadContext, updateContext } from '../config/context.js';
-import { UsageError } from '../core/errors.js';
-import { emitResult, success } from '../core/output.js';
-import { coerceValue } from './shared.js';
-const SETTABLE = new Set([
-    'region',
-    'api_base_url',
-    'platform_base_url',
-    'language',
-    'default_output_dir',
-    'llm.base_url',
-    'llm.api_key',
-    'llm.model',
-]);
-export function registerConfigCommands(program) {
-    const config = program.command('config').description('global config (~/.tripo) and directory context (.tripo)');
-    config
-        .command('list')
-        .description('show effective config (key masked)')
-        .action(() => {
-        const cfg = loadConfig();
-        const shown = {
-            ...cfg,
-            api_key: cfg.api_key ? maskKey(cfg.api_key) : undefined,
-            llm: cfg.llm ? { ...cfg.llm, api_key: cfg.llm.api_key ? maskKey(cfg.llm.api_key) : undefined } : undefined,
-        };
-        const context = loadContext();
-        emitResult({ config: shown, context, context_file: findContextFile() }, JSON.stringify({ config: shown, context }, null, 2));
-    });
-    config
-        .command('set <key> <value>')
-        .description(`set a config value (${[...SETTABLE].join(', ')})`)
-        .action((key, value) => {
-        if (!SETTABLE.has(key)) {
-            throw new UsageError(`unknown config key "${key}" (valid: ${[...SETTABLE].join(', ')})`);
-        }
-        const cfg = loadConfig();
-        applyPath(cfg, key.split('.'), coerceValue(value));
-        saveConfig(cfg);
-        success(`${key} = ${key.includes('api_key') ? maskKey(value) : value}`);
-    });
-    config
-        .command('unset <key>')
-        .description('remove a config value')
-        .action((key) => {
-        const cfg = loadConfig();
-        const parts = key.split('.');
-        const parent = parts.slice(0, -1).reduce((acc, part) => (acc && typeof acc[part] === 'object' ? acc[part] : undefined), cfg);
-        if (parent)
-            delete parent[parts[parts.length - 1]];
-        saveConfig(cfg);
-        success(`${key} removed`);
-    });
-    config
-        .command('context [entries...]')
-        .description('set directory context: tripo config context default_scenario=game-mobile output_dir=./assets')
-        .action((entries) => {
-        if (entries.length === 0) {
-            const ctx = loadContext();
-            emitResult({ context: ctx, file: findContextFile() }, JSON.stringify(ctx, null, 2));
-            return;
-        }
-        const patch = {};
-        for (const entry of entries) {
-            const eq = entry.indexOf('=');
-            if (eq <= 0)
-                throw new UsageError(`context entries are key=value (got "${entry}")`);
-            patch[entry.slice(0, eq)] = coerceValue(entry.slice(eq + 1));
-        }
-        updateContext(patch);
-        success(`context updated: ${Object.keys(patch).join(', ')}`);
-    });
-}
-function applyPath(obj, path, value) {
-    let node = obj;
-    for (const part of path.slice(0, -1)) {
-        if (typeof node[part] !== 'object' || node[part] === null)
-            node[part] = {};
-        node = node[part];
-    }
-    node[path[path.length - 1]] = value;
-}