@agent-creator/cli 0.4.2

package/dist/src/capabilities/agent-core/files/service/src/components/AgentChat.tsx

@@ -0,0 +1,146 @@
+'use client';
+
+import { Alert, Button, Card, Input, Layout, Space, Tag, Typography } from 'antd';
+import { useMemo, useState } from 'react';
+import type { AgentOutput, AgentProgressEvent } from '@agent-creator/core';
+
+interface Message {
+  role: 'user' | 'agent';
+  content: string;
+  output?: AgentOutput;
+  progress?: AgentProgressEvent[];
+}
+
+export function AgentChat() {
+  const [input, setInput] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [messages, setMessages] = useState<Message[]>([]);
+  const sessionId = useMemo(() => `web_${Date.now()}`, []);
+
+  async function send() {
+    const text = input.trim();
+    if (!text) return;
+    setInput('');
+    setLoading(true);
+    setMessages((current) => [...current, { role: 'user', content: text }]);
+    const agentMessageIndex = messages.length + 1;
+    setMessages((current) => [...current, { role: 'agent', content: 'Agent is working...', progress: [] }]);
+    try {
+      const response = await fetch('/api/agent/stream', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: text, sessionId }),
+      });
+      if (!response.body) throw new Error('Streaming response is unavailable.');
+      await readStream(response.body, {
+        onProgress(event) {
+          setMessages((current) => current.map((message, index) => index === agentMessageIndex
+            ? { ...message, content: event.message, progress: [...(message.progress ?? []), event] }
+            : message));
+        },
+        onFinal(output) {
+          setMessages((current) => current.map((message, index) => index === agentMessageIndex
+            ? { ...message, content: output.message, output }
+            : message));
+        },
+      });
+    } catch (error) {
+      setMessages((current) => current.map((message, index) => index === agentMessageIndex
+        ? { ...message, content: error instanceof Error ? error.message : String(error) }
+        : message));
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return (
+    <Layout className="appShell">
+      <div className="content">
+        <Space direction="vertical" size={16} style={{ width: '100%' }}>
+          <Space align="center" style={{ justifyContent: 'space-between', width: '100%' }}>
+            <div>
+              <Typography.Title level={2} style={{ marginBottom: 0 }}>{{projectName}}</Typography.Title>
+              <Typography.Text type="secondary">Agent service example shell</Typography.Text>
+            </div>
+          </Space>
+          <Card>
+            <Space direction="vertical" size={12} style={{ width: '100%' }}>
+              {messages.length === 0 && (
+                <Alert
+                  type="info"
+                  showIcon
+                  message="Configure the model environment variables, then ask the Agent a question."
+                />
+              )}
+              {messages.map((message, index) => (
+                <Card key={index} size="small" title={message.role === 'user' ? 'You' : 'Agent'}>
+                  <Space direction="vertical" style={{ width: '100%' }}>
+                    <Typography.Text>{message.content}</Typography.Text>
+                    {message.output && (
+                      <Space wrap>
+                        <Tag color={message.output.success ? 'green' : 'red'}>{message.output.success ? 'success' : 'failed'}</Tag>
+                        <Tag>{message.output.intent}</Tag>
+                        {message.output.traceId && <Tag>{message.output.traceId}</Tag>}
+                      </Space>
+                    )}
+                    {message.output?.data !== undefined && (
+                      <pre className="jsonBlock">{JSON.stringify(message.output.data, null, 2)}</pre>
+                    )}
+                    {message.progress && message.progress.length > 0 && (
+                      <pre className="jsonBlock">{message.progress.map((event) => `${event.type}: ${event.message}`).join('\n')}</pre>
+                    )}
+                  </Space>
+                </Card>
+              ))}
+              <Input.Search
+                value={input}
+                enterButton={<Button type="primary" loading={loading}>Send</Button>}
+                placeholder="Ask the agent..."
+                onChange={(event) => setInput((event.target as unknown as { value: string }).value)}
+                onSearch={send}
+                disabled={loading}
+              />
+            </Space>
+          </Card>
+        </Space>
+      </div>
+    </Layout>
+  );
+}
+
+async function readStream(
+  body: ReadableStream<Uint8Array>,
+  handlers: {
+    onProgress(event: AgentProgressEvent): void;
+    onFinal(output: AgentOutput): void;
+  },
+) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() ?? '';
+    for (const line of lines) handleLine(line, handlers);
+  }
+  if (buffer.trim()) handleLine(buffer, handlers);
+}
+
+function handleLine(
+  line: string,
+  handlers: {
+    onProgress(event: AgentProgressEvent): void;
+    onFinal(output: AgentOutput): void;
+  },
+) {
+  if (!line.trim()) return;
+  const event = JSON.parse(line) as
+    | { type: 'progress'; event: AgentProgressEvent }
+    | { type: 'final'; output: AgentOutput };
+  if (event.type === 'progress') handlers.onProgress(event.event);
+  else handlers.onFinal(event.output);
+}

package/dist/src/capabilities/capabilityRegistry.d.ts

@@ -0,0 +1,3 @@
+import type { AgentCapabilityDefinition } from '../types/capability.js';
+export declare function getCapability(name: string): AgentCapabilityDefinition;
+export declare function listCapabilities(): AgentCapabilityDefinition[];

package/dist/src/capabilities/capabilityRegistry.js

@@ -0,0 +1,16 @@
+import { agentCoreCapability } from './agent-core/capability.config.js';
+const capabilities = new Map([
+    [agentCoreCapability.name, agentCoreCapability],
+]);
+export function getCapability(name) {
+    if (name !== 'agent-core') {
+        throw new Error('当前版本只支持 agent-core。RAG、workflow、guard 等能力会以 add 命令或模块形式扩展。');
+    }
+    const capability = capabilities.get(name);
+    if (!capability)
+        throw new Error(`Capability not found: ${name}`);
+    return capability;
+}
+export function listCapabilities() {
+    return [...capabilities.values()];
+}

package/dist/src/capabilities/index.d.ts

@@ -0,0 +1 @@
+export { getCapability, listCapabilities } from './capabilityRegistry.js';

package/dist/src/capabilities/index.js

@@ -0,0 +1 @@
+export { getCapability, listCapabilities } from './capabilityRegistry.js';

package/dist/src/cli/cli.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function buildCli(): Command;
+export declare function runCli(argv: string[]): void;

package/dist/src/cli/cli.js

@@ -0,0 +1,63 @@
+import { Command } from 'commander';
+import { addSkillCommand } from '../commands/addSkill.js';
+import { addToolCommand } from '../commands/addTool.js';
+import { createCommand } from '../commands/create.js';
+import { devCommand } from '../commands/dev.js';
+import { traceCommand } from '../commands/trace.js';
+import { validateCommand } from '../commands/validate.js';
+import { CLI_VERSION } from '../version.js';
+export function buildCli() {
+    const program = new Command();
+    program
+        .name('agent')
+        .description('Create and maintain runnable Agent projects.')
+        .version(CLI_VERSION);
+    program
+        .command('create')
+        .argument('<name>', 'project name')
+        .option('--capability <capability>', 'agent capability name', 'agent-core')
+        .option('--mode <mode>', 'generation mode: package | service', 'service')
+        .option('--package-manager <packageManager>', 'package manager', 'npm')
+        .option('--force', 'overwrite an existing directory', false)
+        .action(createCommand);
+    program
+        .command('validate')
+        .description('Validate the current generated Agent project.')
+        .action(validateCommand);
+    program
+        .command('version')
+        .description('Print the Agent Creator CLI version.')
+        .action(() => {
+        console.log(program.version());
+    });
+    program
+        .command('help')
+        .description('Print Agent Creator CLI help.')
+        .action(() => {
+        program.outputHelp();
+    });
+    program
+        .command('dev')
+        .description('Run the generated Agent interactive console.')
+        .action(devCommand);
+    program
+        .command('trace')
+        .option('--latest', 'show the latest trace', false)
+        .option('--list', 'list traces', false)
+        .option('--id <traceId>', 'show a trace by id')
+        .action(traceCommand);
+    const add = program.command('add').description('Add generated project modules.');
+    add
+        .command('skill')
+        .argument('<skillName>', 'skill name')
+        .action(addSkillCommand);
+    add
+        .command('tool')
+        .argument('<toolName>', 'tool name')
+        .description('Deprecated alias for agent add skill.')
+        .action(addToolCommand);
+    return program;
+}
+export function runCli(argv) {
+    buildCli().parse(argv);
+}

package/dist/src/commands/addSkill.d.ts

@@ -0,0 +1,2 @@
+import type { AddToolOptions } from '../types/cli.js';
+export declare function addSkillCommand(skillName: string, _options?: AddToolOptions): Promise<void>;

package/dist/src/commands/addSkill.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { pathExists, readText, writeFileEnsured } from '../utils/fs.js';
+import { assertSafeName, toCamelCase, toKebabCase, toToolName } from '../utils/string.js';
+import { logger } from '../utils/logger.js';
+export async function addSkillCommand(skillName, _options = {}) {
+    assertSafeName(skillName);
+    if (!(await pathExists('agent.config.ts')) || !(await pathExists('src/skills/index.ts'))) {
+        throw new Error('agent add skill must be run from a generated Agent project root.');
+    }
+    const fileName = toKebabCase(skillName);
+    const symbolName = `${toCamelCase(skillName)}Skill`;
+    const dottedName = toToolName(skillName);
+    const target = path.join(process.cwd(), 'src/skills', `${fileName}.ts`);
+    if (await pathExists(target))
+        throw new Error(`Skill already exists: src/skills/${fileName}.ts`);
+    await writeFileEnsured(target, skillFile(symbolName, dottedName));
+    await updateSkillsIndex(fileName, symbolName, dottedName);
+    await updateAgentConfig(dottedName);
+    logger.success(`Added skill ${dottedName}.`);
+}
+function skillFile(symbolName, dottedName) {
+    return `import { z } from 'zod';
+import type { Skill } from '@agent-creator/core';
+
+const inputSchema = z.object({
+  query: z.string().min(1),
+});
+
+const outputSchema = z.object({
+  ok: z.boolean(),
+  result: z.string(),
+});
+
+export const ${symbolName}: Skill<z.infer<typeof inputSchema>, z.infer<typeof outputSchema>> = {
+  name: '${dottedName}',
+  description: 'Generated skill skeleton.',
+  inputSchema,
+  outputSchema,
+  async execute(input) {
+    return { ok: true, result: \`Handled \${input.query}\` };
+  },
+};
+`;
+}
+async function updateSkillsIndex(fileName, symbolName, dottedName) {
+    const indexPath = path.join(process.cwd(), 'src/skills/index.ts');
+    let text = await readText(indexPath);
+    text = `import { ${symbolName} } from './${fileName}.js';\n${text}`;
+    text = text.replace('// agent-creator:skill-imports', `// agent-creator:skill-imports\n  ${symbolName},`);
+    text = text.replace('// agent-creator:skill-exports', `// agent-creator:skill-exports\n  '${dottedName}',`);
+    await writeFileEnsured(indexPath, text);
+}
+async function updateAgentConfig(dottedName) {
+    const configPath = path.join(process.cwd(), 'agent.config.ts');
+    let text = await readText(configPath);
+    text = text.replace('// agent-creator:skills', `// agent-creator:skills\n      '${dottedName}',`);
+    await writeFileEnsured(configPath, text);
+}

package/dist/src/commands/addTool.d.ts

@@ -0,0 +1,3 @@
+import type { AddToolOptions } from '../types/cli.js';
+/** @deprecated Use agent add skill. */
+export declare function addToolCommand(toolName: string, options: AddToolOptions): Promise<void>;

package/dist/src/commands/addTool.js

@@ -0,0 +1,7 @@
+import { logger } from '../utils/logger.js';
+import { addSkillCommand } from './addSkill.js';
+/** @deprecated Use agent add skill. */
+export async function addToolCommand(toolName, options) {
+    logger.warn('agent add tool is deprecated; use agent add skill.');
+    await addSkillCommand(toolName, options);
+}

package/dist/src/commands/create.d.ts

@@ -0,0 +1,2 @@
+import type { CreateOptions } from '../types/cli.js';
+export declare function createCommand(name: string, options: CreateOptions): Promise<void>;

package/dist/src/commands/create.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getCapability } from '../capabilities/index.js';
+import { pathExists, writeFileEnsured } from '../utils/fs.js';
+import { resolveProjectPath } from '../utils/path.js';
+import { logger } from '../utils/logger.js';
+import { installCommand } from '../utils/packageManager.js';
+export async function createCommand(name, options) {
+    const capabilityName = options.capability ?? 'agent-core';
+    const mode = options.mode ?? 'service';
+    if (!['package', 'service'].includes(mode)) {
+        throw new Error(`Unsupported create mode "${mode}". Use "package" or "service".`);
+    }
+    const capability = getCapability(capabilityName);
+    const targetDir = resolveProjectPath(name);
+    if (await pathExists(targetDir)) {
+        if (!options.force) {
+            throw new Error(`Directory already exists: ${targetDir}. Use --force to overwrite.`);
+        }
+        await fs.rm(targetDir, { recursive: true, force: true });
+    }
+    for (const file of await capability.files(name, { ...options, mode })) {
+        await writeFileEnsured(path.join(targetDir, file.path), file.content);
+    }
+    const packageManager = options.packageManager ?? 'npm';
+    logger.success(`Created ${name} with ${capability.name}.`);
+    logger.info('');
+    logger.info(`cd ${name}`);
+    logger.info(installCommand(packageManager));
+    logger.info('npm run dev');
+    logger.info('npm test');
+}

package/dist/src/commands/dev.d.ts

@@ -0,0 +1 @@
+export declare function devCommand(): Promise<void>;

package/dist/src/commands/dev.js

@@ -0,0 +1,11 @@
+import { spawn } from 'node:child_process';
+import { pathExists } from '../utils/fs.js';
+export async function devCommand() {
+    if (!(await pathExists('src/dev.ts'))) {
+        throw new Error('agent dev must be run from a generated Agent project root.');
+    }
+    const child = spawn('npm', ['run', 'dev'], { stdio: 'inherit', shell: process.platform === 'win32' });
+    child.on('exit', (code) => {
+        process.exitCode = code ?? 0;
+    });
+}

package/dist/src/commands/trace.d.ts

@@ -0,0 +1,7 @@
+interface TraceOptions {
+    latest?: boolean;
+    list?: boolean;
+    id?: string;
+}
+export declare function traceCommand(options: TraceOptions): Promise<void>;
+export {};

package/dist/src/commands/trace.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathExists, readText } from '../utils/fs.js';
+import { logger } from '../utils/logger.js';
+export async function traceCommand(options) {
+    const directory = path.resolve(process.cwd(), '.agent-traces');
+    if (!(await pathExists(directory))) {
+        throw new Error('No .agent-traces directory found. Run this in a generated Agent project.');
+    }
+    const files = (await fs.readdir(directory))
+        .filter((file) => file.endsWith('.json'))
+        .sort();
+    if (options.list) {
+        if (files.length === 0) {
+            logger.info('No traces found.');
+            return;
+        }
+        for (const file of files)
+            logger.info(file.replace(/\.json$/, ''));
+        return;
+    }
+    const selected = options.id ? `${options.id}.json` : files.at(-1);
+    if (!selected) {
+        logger.info('No traces found.');
+        return;
+    }
+    const content = await readText(path.join(directory, selected));
+    const trace = JSON.parse(content);
+    if (options.latest || !options.id) {
+        logger.info(`${trace.traceId}  ${trace.finalOutput?.intent ?? 'unknown'}  ${trace.finalOutput?.success ? 'success' : 'failed'}  ${trace.latencyMs ?? 0}ms`);
+        logger.info(content);
+        return;
+    }
+    logger.info(content);
+}

package/dist/src/commands/validate.d.ts

@@ -0,0 +1 @@
+export declare function validateCommand(): Promise<void>;

package/dist/src/commands/validate.js

@@ -0,0 +1,166 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { pathToFileURL } from 'node:url';
+import ts from 'typescript';
+import { agentConfigSchema } from '../schemas/agentConfig.schema.js';
+import { pathExists, readText } from '../utils/fs.js';
+import { logger } from '../utils/logger.js';
+import { SUPPORTED_CONFIG_VERSIONS } from '../version.js';
+export async function validateCommand() {
+    const cwd = process.cwd();
+    const issues = [];
+    const required = [
+        'agent.config.ts',
+        'package.json',
+        'src/index.ts',
+        'src/skills/index.ts',
+    ];
+    for (const file of required) {
+        if (!(await pathExists(path.join(cwd, file)))) {
+            issues.push({ location: file, reason: 'Required file is missing.', fix: `Restore or regenerate ${file}.` });
+        }
+    }
+    const configPath = path.join(cwd, 'agent.config.ts');
+    if (await pathExists(configPath)) {
+        const configResult = await loadAndValidateConfig(configPath);
+        if (!configResult.config) {
+            issues.push(...configResult.issues);
+        }
+        else if (!SUPPORTED_CONFIG_VERSIONS.includes(configResult.config.configVersion)) {
+            issues.push({
+                location: 'agent.config.ts:configVersion',
+                reason: `Unsupported configVersion "${configResult.config.configVersion}".`,
+                fix: `Use one of: ${SUPPORTED_CONFIG_VERSIONS.join(', ')}. Future versions may provide agent migrate.`,
+            });
+        }
+        else {
+            if (configResult.config.service.enabled && configResult.config.service.framework !== 'next') {
+                issues.push({
+                    location: 'agent.config.ts:service',
+                    reason: 'Generated service-enabled projects must use Next.js.',
+                    fix: "Set service.framework to 'next' or set service.enabled to false for package mode.",
+                });
+            }
+            if (configResult.config.service.enabled) {
+                await validateServiceProject(cwd, issues);
+            }
+        }
+        const enabledSkills = configResult.config?.skills.enabled ?? extractEnabledSkills(await readText(configPath));
+        const skillsIndex = await pathExists(path.join(cwd, 'src/skills/index.ts'))
+            ? await readText(path.join(cwd, 'src/skills/index.ts'))
+            : '';
+        for (const skill of enabledSkills) {
+            if (!skillsIndex.includes(`'${skill}'`)) {
+                issues.push({
+                    location: 'agent.config.ts',
+                    reason: `Enabled skill "${skill}" is not registered in src/skills/index.ts.`,
+                    fix: 'Register the skill with agent add skill or remove it from skills.enabled.',
+                });
+            }
+        }
+        await validateCoreDependency(cwd, issues);
+    }
+    if (issues.length > 0) {
+        logger.error('Agent project validation failed:');
+        for (const issue of issues) {
+            logger.error(`- ${issue.location}: ${issue.reason} Fix: ${issue.fix}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    logger.success('Agent project validation passed.');
+}
+async function validateServiceProject(cwd, issues) {
+    const required = [
+        'src/app/page.tsx',
+        'src/app/api/agent/route.ts',
+        'src/components/AgentChat.tsx',
+    ];
+    for (const file of required) {
+        if (!(await pathExists(path.join(cwd, file)))) {
+            issues.push({ location: file, reason: 'Required service file is missing.', fix: `Restore ${file} from the agent-core capability.` });
+        }
+    }
+    const packagePath = path.join(cwd, 'package.json');
+    if (!(await pathExists(packagePath)))
+        return;
+    const packageJson = JSON.parse(await readText(packagePath));
+    const dependencies = packageJson.dependencies ?? {};
+    for (const dependency of ['next', 'react', 'react-dom', 'antd', '@ant-design/nextjs-registry']) {
+        if (!dependencies[dependency]) {
+            issues.push({
+                location: 'package.json',
+                reason: `Generated service Agent requires dependency "${dependency}".`,
+                fix: `Add ${dependency} to dependencies.`,
+            });
+        }
+    }
+}
+async function validateCoreDependency(cwd, issues) {
+    const packagePath = path.join(cwd, 'package.json');
+    if (!(await pathExists(packagePath)))
+        return;
+    const packageJson = JSON.parse(await readText(packagePath));
+    if (!packageJson.dependencies?.['@agent-creator/core']) {
+        issues.push({
+            location: 'package.json',
+            reason: 'Generated Agent requires @agent-creator/core.',
+            fix: 'Add @agent-creator/core to dependencies.',
+        });
+    }
+}
+function extractEnabledSkills(configText) {
+    const match = configText.match(/enabled:\s*\[([\s\S]*?)\]/m);
+    if (!match)
+        return [];
+    return [...match[1].matchAll(/'([^']+)'/g)].map((item) => item[1]);
+}
+async function loadAndValidateConfig(configPath) {
+    try {
+        const loaded = await loadConfig(configPath);
+        const parsed = agentConfigSchema.safeParse(loaded);
+        if (parsed.success)
+            return { config: parsed.data, issues: [] };
+        return {
+            issues: parsed.error.issues.map((issue) => ({
+                location: `agent.config.ts:${issue.path.join('.') || 'default'}`,
+                reason: issue.message,
+                fix: 'Update agent.config.ts to match the AgentConfig schema documented in docs/generated-agent-runtime.md.',
+            })),
+        };
+    }
+    catch (error) {
+        return {
+            issues: [
+                {
+                    location: 'agent.config.ts',
+                    reason: `Could not load config: ${error instanceof Error ? error.message : String(error)}`,
+                    fix: 'Run npm install in the generated project and make sure agent.config.ts has a valid default export.',
+                },
+            ],
+        };
+    }
+}
+async function loadConfig(configPath) {
+    const source = await readText(configPath);
+    const transpiled = ts.transpileModule(source, {
+        compilerOptions: {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ES2022,
+            moduleResolution: ts.ModuleResolutionKind.NodeNext,
+            importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Remove,
+        },
+        fileName: configPath,
+    });
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-config-'));
+    const tempFile = path.join(tempDir, 'agent.config.mjs');
+    await fs.writeFile(tempFile, transpiled.outputText, 'utf8');
+    try {
+        const imported = await import(`${pathToFileURL(tempFile).href}?t=${Date.now()}`);
+        return imported.default;
+    }
+    finally {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runCli } from './cli/cli.js';
+runCli(process.argv);