opc-agent 1.3.2 → 2.0.0

package/dist/cli.js

@@ -61,7 +61,7 @@ const workflow_1 = require("./core/workflow");
 const versioning_1 = require("./core/versioning");
 const providers_1 = require("./providers");
 const knowledge_1 = require("./core/knowledge");
-const marketplace_1 = require("./marketplace");
+const child_process_1 = require("child_process");
 const program = new commander_1.Command();
 const color = {
     green: (s) => `\x1b[32m${s}\x1b[0m`,
@@ -119,7 +119,7 @@ async function select(question, options) {
 program
     .name('opc')
     .description('OPC Agent - Open Agent Framework for business workstations')
-    .version('1.0.0');
+    .version('2.0.0');
 // ── Init command ─────────────────────────────────────────────
 program
     .command('init')
@@ -139,6 +139,7 @@ program
         process.exit(1);
     }
     fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(path.join(dir, 'src', 'skills'), { recursive: true });
     const factory = TEMPLATES[template]?.factory ?? customer_service_1.createCustomerServiceConfig;
     const config = factory();
     config.metadata.name = name;
@@ -147,6 +148,102 @@ program
         config.spec.channels.push({ type: 'web', port: 3000 });
     }
     fs.writeFileSync(path.join(dir, 'oad.yaml'), yaml.dump(config, { lineWidth: 120 }));
+    // agent.yaml — standalone OAD config for runtime usage
+    fs.writeFileSync(path.join(dir, 'agent.yaml'), `apiVersion: opc/v1
+kind: Agent
+metadata:
+  name: ${name}
+  version: 1.0.0
+  description: My AI Agent
+spec:
+  model: qwen2.5
+  provider:
+    default: ollama
+  systemPrompt: |
+    You are a helpful AI assistant named ${name}.
+    Be concise, helpful, and friendly.
+  channels:
+    - type: web
+      port: 3000
+  memory:
+    shortTerm: true
+    longTerm:
+      provider: deepbrain
+  skills:
+    - name: echo
+      description: Echo test skill
+`);
+    // src/index.ts — entry point
+    fs.writeFileSync(path.join(dir, 'src', 'index.ts'), `import { AgentRuntime } from 'opc-agent';
+import { EchoSkill } from './skills/echo';
+import { readFileSync, existsSync } from 'fs';
+
+async function main() {
+  const runtime = new AgentRuntime();
+
+  // Load OAD config
+  const config = await runtime.loadConfig('./agent.yaml');
+
+  // Load personality and context files
+  const soul = existsSync('./SOUL.md') ? readFileSync('./SOUL.md', 'utf-8') : '';
+  const context = existsSync('./CONTEXT.md') ? readFileSync('./CONTEXT.md', 'utf-8') : '';
+  if (soul || context) {
+    const fullPrompt = [soul, context, config.spec.systemPrompt].filter(Boolean).join('\\n\\n');
+    config.spec.systemPrompt = fullPrompt;
+  }
+
+  // Initialize agent with channels, memory, etc.
+  const agent = await runtime.initialize(config);
+
+  // Register custom skills
+  runtime.registerSkill(new EchoSkill());
+
+  // Start serving
+  await runtime.start();
+
+  console.log('🤖 Agent is running!');
+  console.log('   Web UI: http://localhost:3000');
+  console.log('   Press Ctrl+C to stop');
+}
+
+main().catch(console.error);
+`);
+    // src/skills/echo.ts — example skill
+    fs.writeFileSync(path.join(dir, 'src', 'skills', 'echo.ts'), `import { BaseSkill } from 'opc-agent';
+import type { AgentContext, Message, SkillResult } from 'opc-agent';
+
+export class EchoSkill extends BaseSkill {
+  name = 'echo';
+  description = 'Echo back the message (test skill)';
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    if (message.content.toLowerCase().startsWith('/echo ')) {
+      const text = message.content.slice(6);
+      return this.match(\`🔊 Echo: \${text}\`);
+    }
+    return this.noMatch();
+  }
+}
+`);
+    // tsconfig.json
+    fs.writeFileSync(path.join(dir, 'tsconfig.json'), JSON.stringify({
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'commonjs',
+            lib: ['ES2022'],
+            outDir: 'dist',
+            rootDir: 'src',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            declaration: true,
+            sourceMap: true,
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules', 'dist'],
+    }, null, 2));
     // .env.example
     fs.writeFileSync(path.join(dir, '.env.example'), `# LLM API Configuration
 OPC_LLM_API_KEY=your-api-key-here
@@ -157,9 +254,9 @@ OPC_LLM_MODEL=gpt-4o-mini
 # OPC_LLM_BASE_URL=https://api.deepseek.com/v1
 # OPC_LLM_MODEL=deepseek-chat
 
-# For local Ollama:
+# For local Ollama (default in agent.yaml):
 # OPC_LLM_BASE_URL=http://localhost:11434/v1
-# OPC_LLM_MODEL=llama3
+# OPC_LLM_MODEL=qwen2.5
 `);
     // .env (copy of example)
     fs.writeFileSync(path.join(dir, '.env'), `OPC_LLM_API_KEY=your-api-key-here
@@ -173,20 +270,27 @@ OPC_LLM_MODEL=gpt-4o-mini
         private: true,
         scripts: {
             start: 'opc run',
+            dev: 'opc dev',
             chat: 'opc chat',
+            build: 'tsc',
         },
         dependencies: {
-            'opc-agent': '^0.5.0',
+            'opc-agent': '^1.3.0',
+        },
+        devDependencies: {
+            typescript: '^5.5.0',
+            tsx: '^4.0.0',
         },
     }, null, 2));
     // .gitignore
-    fs.writeFileSync(path.join(dir, '.gitignore'), 'node_modules\n.env\n.opc-knowledge.json\ndata/\n');
+    fs.writeFileSync(path.join(dir, '.gitignore'), 'node_modules\ndist\n.env\n.opc-knowledge.json\ndata/\n');
     // Dockerfile
     fs.writeFileSync(path.join(dir, 'Dockerfile'), `FROM node:22-alpine
 WORKDIR /app
 COPY package.json package-lock.json* ./
 RUN npm ci --production 2>/dev/null || npm install --production
-COPY oad.yaml .env* ./
+COPY oad.yaml agent.yaml .env* ./
+COPY src/ ./src/
 COPY prompts/ ./prompts/ 2>/dev/null || true
 EXPOSE 3000
 CMD ["npx", "opc", "run"]
@@ -201,7 +305,7 @@ services:
     env_file:
       - .env
     volumes:
-      - ./oad.yaml:/app/oad.yaml:ro
+      - ./agent.yaml:/app/agent.yaml:ro
     restart: unless-stopped
 `);
     // README.md
@@ -211,51 +315,108 @@ Created with [OPC Agent](https://github.com/Deepleaper/opc-agent) using the \`${
 
 ## Quick Start
 
-1. **Set your API key:**
+1. **Install dependencies:**
    \`\`\`bash
-   # Edit .env and add your API key
-   cp .env.example .env
-   # Then edit .env with your actual key
+   npm install
    \`\`\`
 
-2. **Install dependencies:**
+2. **Run with Ollama (default):**
    \`\`\`bash
-   npm install
+   # Make sure Ollama is running with qwen2.5 model
+   ollama pull qwen2.5
+   npx tsx src/index.ts
    \`\`\`
 
-3. **Start the web server:**
+3. **Or use OpenAI/other providers:**
    \`\`\`bash
+   # Edit .env and set your API key
    npx opc run
    \`\`\`
 
 4. **Open browser:** [http://localhost:3000](http://localhost:3000)
 
-## CLI Chat
+## Development
 
 \`\`\`bash
-npx opc chat
+npx opc dev    # Hot-reload mode
+npx opc chat   # CLI chat
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${name}/
+├── agent.yaml          # OAD agent config (used by src/index.ts)
+├── oad.yaml            # OAD config (used by opc CLI)
+├── src/
+│   ├── index.ts        # Entry point
+│   └── skills/
+│       └── echo.ts     # Example skill
+├── package.json
+└── tsconfig.json
 \`\`\`
 
 ## Configuration
 
-Edit \`oad.yaml\` to customize your agent's personality, skills, and behavior.
+Edit \`agent.yaml\` to customize your agent's personality, skills, and behavior.
+`);
+    // SOUL.md — agent personality
+    const createdDate = new Date().toISOString().split('T')[0];
+    fs.writeFileSync(path.join(dir, 'SOUL.md'), `# ${name} Personality
+
+## Identity
+- Name: ${name}
+- Role: AI Assistant
+- Created: ${createdDate}
+
+## Personality Traits
+- Helpful and professional
+- Concise but thorough
+- Friendly tone
+
+## Communication Style
+- Use clear, simple language
+- Be direct — answer the question first, then explain
+- Use markdown formatting when helpful
+
+## Rules
+- Always be honest about limitations
+- Ask for clarification when the request is ambiguous
+- Never make up information
+`);
+    // CONTEXT.md — project context
+    fs.writeFileSync(path.join(dir, 'CONTEXT.md'), `# Project Context
+
+## About This Agent
+${name} is an AI agent built with OPC Agent Framework.
+
+## Knowledge Base
+Add project-specific context here. The agent reads this file
+on startup to understand the project context.
+
+## Important Notes
+- Add domain knowledge here
+- Add FAQ items here
+- Add company policies here
 `);
     console.log(`\n${icon.success} Created agent project: ${color.bold(name + '/')}`);
-    console.log(`   ${icon.file} oad.yaml      - Agent definition`);
-    console.log(`   ${icon.file} package.json  - Dependencies`);
-    console.log(`   ${icon.file} .env.example  - Environment template`);
-    console.log(`   ${icon.file} .env          - Environment config (edit this!)`);
+    console.log(`   ${icon.file} agent.yaml       - Agent definition (OAD)`);
+    console.log(`   ${icon.file} src/index.ts     - Entry point`);
+    console.log(`   ${icon.file} src/skills/echo.ts - Example skill`);
+    console.log(`   ${icon.file} SOUL.md          - Agent personality`);
+    console.log(`   ${icon.file} CONTEXT.md       - Project context`);
+    console.log(`   ${icon.file} package.json     - Dependencies`);
+    console.log(`   ${icon.file} tsconfig.json    - TypeScript config`);
+    console.log(`   ${icon.file} .env.example     - Environment template`);
     console.log(`   ${icon.file} .gitignore`);
     console.log(`   ${icon.file} Dockerfile`);
-    console.log(`   ${icon.file} docker-compose.yml`);
     console.log(`   ${icon.file} README.md`);
     console.log(`\n   Template: ${color.cyan(template)}`);
     console.log(`\n${color.bold('Next steps:')}`);
     console.log(`   1. cd ${name}`);
-    console.log(`   2. Edit .env — set your OPC_LLM_API_KEY`);
-    console.log(`   3. npm install`);
-    console.log(`   4. npx opc run`);
-    console.log(`   5. Open http://localhost:3000\n`);
+    console.log(`   2. npm install`);
+    console.log(`   3. npx tsx src/index.ts   ${color.dim('# or: npx opc run')}`);
+    console.log(`   4. Open http://localhost:3000\n`);
 });
 // ── Chat command ─────────────────────────────────────────────
 program
@@ -267,6 +428,15 @@ program
     loadDotEnv();
     let systemPrompt = 'You are a helpful AI agent.';
     let model;
+    let agentName = 'Agent';
+    let agentVersion = '1.0.0';
+    let providerName = 'openai';
+    let skillNames = [];
+    // Try loading SOUL.md and CONTEXT.md for enriched system prompt
+    const soulPath = path.resolve('SOUL.md');
+    const contextPath = path.resolve('CONTEXT.md');
+    const soulContent = fs.existsSync(soulPath) ? fs.readFileSync(soulPath, 'utf-8') : '';
+    const contextContent = fs.existsSync(contextPath) ? fs.readFileSync(contextPath, 'utf-8') : '';
     try {
         const raw = fs.readFileSync(opts.file, 'utf-8');
         const config = yaml.load(raw);
@@ -274,15 +444,93 @@ program
             systemPrompt = config.spec.systemPrompt;
         if (config?.spec?.model)
             model = config.spec.model;
-        console.log(`\n${icon.gear} Loaded agent: ${color.bold(config?.metadata?.name ?? 'unknown')}`);
+        if (config?.metadata?.name)
+            agentName = config.metadata.name;
+        if (config?.metadata?.version)
+            agentVersion = config.metadata.version;
+        if (config?.spec?.provider?.default)
+            providerName = config.spec.provider.default;
+        if (config?.spec?.skills)
+            skillNames = config.spec.skills.map((s) => s.name);
     }
     catch {
-        console.log(`\n${icon.info} No oad.yaml found, using defaults.`);
+        // No config file, use defaults
     }
+    // Prepend SOUL.md and CONTEXT.md to system prompt
+    systemPrompt = [soulContent, contextContent, systemPrompt].filter(Boolean).join('\n\n');
     const provider = (0, providers_1.createProvider)('openai', model);
     const history = [];
-    console.log(`${color.dim('Type your message. Press Ctrl+C to exit.')}\n`);
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    // Print startup banner
+    const bannerLines = [
+        '╔══════════════════════════════════════╗',
+        '║  🤖 OPC Agent — Interactive Chat     ║',
+        `║  Agent: ${(agentName + ' v' + agentVersion).padEnd(27)}║`,
+        `║  Model: ${((providerName + '/' + (model ?? 'default')).slice(0, 27)).padEnd(27)}║`,
+        `║  Skills: ${(String(skillNames.length) + ' loaded').padEnd(26)}║`,
+        '║  Type /help for commands             ║',
+        '╚══════════════════════════════════════╝',
+    ];
+    console.log('\n' + color.cyan(bannerLines.join('\n')) + '\n');
+    if (soulContent)
+        console.log(`  ${icon.info} Loaded SOUL.md`);
+    if (contextContent)
+        console.log(`  ${icon.info} Loaded CONTEXT.md`);
+    if (soulContent || contextContent)
+        console.log();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        historySize: 100,
+    });
+    const handleSlashCommand = (cmd) => {
+        const lower = cmd.toLowerCase().trim();
+        if (lower === '/quit' || lower === '/exit') {
+            console.log(`\n${color.dim('Goodbye! 👋')}`);
+            process.exit(0);
+        }
+        if (lower === '/help') {
+            console.log(`\n  ${color.bold('Available commands:')}`);
+            console.log(`  ${color.cyan('/help')}    — Show this help`);
+            console.log(`  ${color.cyan('/quit')}    — Exit chat (/exit also works)`);
+            console.log(`  ${color.cyan('/clear')}   — Clear conversation history`);
+            console.log(`  ${color.cyan('/skills')}  — List registered skills`);
+            console.log(`  ${color.cyan('/memory')}  — Show memory stats`);
+            console.log(`  ${color.cyan('/info')}    — Show agent info\n`);
+            return true;
+        }
+        if (lower === '/clear') {
+            history.length = 0;
+            console.log(`\n  ${icon.success} Conversation history cleared.\n`);
+            return true;
+        }
+        if (lower === '/skills') {
+            if (skillNames.length === 0) {
+                console.log(`\n  ${icon.info} No skills registered.\n`);
+            }
+            else {
+                console.log(`\n  ${color.bold('Registered skills:')}`);
+                skillNames.forEach((s) => console.log(`  • ${color.cyan(s)}`));
+                console.log();
+            }
+            return true;
+        }
+        if (lower === '/memory') {
+            console.log(`\n  ${color.bold('Memory stats:')}`);
+            console.log(`  Messages in history: ${color.cyan(String(history.length))}`);
+            console.log(`  Characters: ${color.cyan(String(history.reduce((a, m) => a + m.content.length, 0)))}\n`);
+            return true;
+        }
+        if (lower === '/info') {
+            console.log(`\n  ${color.bold('Agent Info:')}`);
+            console.log(`  Name:     ${color.cyan(agentName)}`);
+            console.log(`  Version:  ${color.cyan(agentVersion)}`);
+            console.log(`  Provider: ${color.cyan(providerName)}`);
+            console.log(`  Model:    ${color.cyan(model ?? 'default')}`);
+            console.log(`  Skills:   ${color.cyan(String(skillNames.length))}\n`);
+            return true;
+        }
+        return false;
+    };
     const ask = () => {
         rl.question(color.cyan('You: '), async (input) => {
             const text = input.trim();
@@ -290,6 +538,11 @@ program
                 ask();
                 return;
             }
+            // Handle slash commands
+            if (text.startsWith('/') && handleSlashCommand(text)) {
+                ask();
+                return;
+            }
             history.push({ role: 'user', content: text });
             // Build messages for provider
             const messages = history.map((m) => ({
@@ -321,7 +574,7 @@ program
         });
     };
     rl.on('close', () => {
-        console.log(`\n${color.dim('Goodbye!')}`);
+        console.log(`\n${color.dim('Goodbye! 👋')}`);
         process.exit(0);
     });
     ask();
@@ -684,51 +937,23 @@ kbCmd.command('clear').action(() => {
     kb.clear();
     console.log(`${icon.success} Knowledge base cleared.`);
 });
-// 📦 Marketplace commands ───────────────────────────────────
+// 📦 Package commands ───────────────────────────────────
 program
     .command('publish')
     .description('Package agent for distribution')
     .option('-f, --file <file>', 'OAD file', 'oad.yaml')
     .option('-o, --output <dir>', 'Output directory', '.')
     .option('--include-kb', 'Include knowledge base')
-    .action(async (opts) => {
-    try {
-        console.log(`\n${icon.package} Packaging agent...\n`);
-        const result = await (0, marketplace_1.publishAgent)({
-            oadPath: opts.file,
-            outputDir: opts.output,
-            includeKnowledge: opts.includeKb,
-        });
-        console.log(`${icon.success} Published: ${color.bold(result.archivePath)}`);
-        console.log(`   Name:    ${result.manifest.name}`);
-        console.log(`   Version: ${result.manifest.version}`);
-        console.log(`   Files:   ${result.manifest.files.length}`);
-        console.log();
-    }
-    catch (err) {
-        console.error(`${icon.error} Publish failed:`, err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
+    .action(async () => {
+    console.log(`\n${icon.package} Agent packaging coming soon.\n`);
 });
 program
     .command('install')
     .description('Install agent from package')
     .argument('<source>', 'Package file path or URL')
     .option('-d, --dir <dir>', 'Install directory')
-    .action(async (source, opts) => {
-    try {
-        console.log(`\n${icon.package} Installing agent from ${color.bold(source)}...\n`);
-        const result = await (0, marketplace_1.installAgent)({ source, targetDir: opts.dir });
-        console.log(`${icon.success} Installed: ${color.bold(result.manifest.name)} v${result.manifest.version}`);
-        console.log(`   Directory: ${result.dir}`);
-        console.log(`\n${color.bold('Next steps:')}`);
-        console.log(`   cd ${result.dir}`);
-        console.log(`   opc run\n`);
-    }
-    catch (err) {
-        console.error(`${icon.error} Install failed:`, err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
+    .action(async () => {
+    console.log(`\n${icon.package} Agent install coming soon.\n`);
 });
 // 🔌 Plugin commands ────────────────────────────────────────
 const pluginCmd = program.command('plugin').description('Manage plugins');
@@ -838,5 +1063,382 @@ program
         process.exit(1);
     }
 });
+// ── Brain command ────────────────────────────────────────────
+program
+    .command('brain')
+    .description('Show agent memory/brain status from DeepBrain')
+    .option('--url <url>', 'DeepBrain server URL', 'http://localhost:3333')
+    .action(async (opts) => {
+    console.log(`\n${icon.gear} ${color.bold('DeepBrain Status')} — ${color.dim(opts.url)}\n`);
+    try {
+        const res = await fetch(`${opts.url}/api/stats`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+        const stats = (await res.json());
+        const rows = [
+            ['Total Pages', String(stats.totalPages ?? stats.pages ?? '-')],
+            ['Total Chunks', String(stats.totalChunks ?? stats.chunks ?? '-')],
+            ['Memory Tiers', String(stats.memoryTiers ?? stats.tiers ?? '-')],
+            ['Index Size', stats.indexSize ?? '-'],
+            ['Last Updated', stats.lastUpdated ?? stats.updatedAt ?? '-'],
+        ];
+        const maxKey = Math.max(...rows.map(([k]) => k.length));
+        for (const [key, val] of rows) {
+            console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('ECONNREFUSED') || msg.includes('fetch failed')) {
+            console.log(`  ${icon.warn} Cannot connect to DeepBrain at ${opts.url}`);
+            console.log(`  ${color.dim('Is the server running? Start with: deepbrain serve')}\n`);
+        }
+        else {
+            console.error(`  ${icon.error} ${msg}\n`);
+        }
+    }
+});
+// ── Logs command ─────────────────────────────────────────────
+program
+    .command('logs')
+    .description('Show recent agent traces')
+    .option('-n, --limit <n>', 'Number of spans to show', '20')
+    .option('-f, --follow', 'Keep watching for new spans')
+    .action(async (opts) => {
+    const { TraceCollector } = await Promise.resolve().then(() => __importStar(require('./traces')));
+    const collector = new TraceCollector();
+    const limit = parseInt(opts.limit) || 20;
+    const printSpans = (spans) => {
+        const slice = spans.slice(-limit);
+        if (slice.length === 0) {
+            console.log(`  ${icon.info} No traces yet. Interact with the agent to generate traces.`);
+            return;
+        }
+        for (const span of slice) {
+            const duration = span.endTime
+                ? `${span.endTime.getTime() - span.startTime.getTime()}ms`
+                : 'ongoing';
+            const statusIcon = span.status === 'ok' ? icon.success : span.status === 'error' ? icon.error : color.dim('○');
+            const time = span.startTime.toLocaleTimeString();
+            console.log(`  ${statusIcon} ${color.dim(time)} ${color.bold(span.name)} ${color.dim(duration)}`);
+        }
+    };
+    console.log(`\n${icon.gear} ${color.bold('Agent Traces')}\n`);
+    const spans = collector.getBufferedSpans();
+    printSpans(spans);
+    if (opts.follow) {
+        console.log(`\n  ${color.dim('Watching for new traces... (Ctrl+C to stop)')}\n`);
+        let lastCount = spans.length;
+        const interval = setInterval(() => {
+            const current = collector.getBufferedSpans();
+            if (current.length > lastCount) {
+                const newSpans = current.slice(lastCount);
+                printSpans(newSpans);
+                lastCount = current.length;
+            }
+        }, 1000);
+        process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
+    }
+    else {
+        console.log();
+    }
+});
+// ── Score command ────────────────────────────────────────────
+program
+    .command('score')
+    .description('Show agent performance score')
+    .action(async () => {
+    console.log(`\n${icon.gear} ${color.bold('Agent Performance Score')}\n`);
+    try {
+        const engine = new analytics_engine_1.AnalyticsEngine('.');
+        const stats = engine.getStats();
+        if (!stats || stats.totalMessages === 0) {
+            console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
+            return;
+        }
+        const errorRate = stats.totalMessages > 0 ? (stats.totalErrors / stats.totalMessages) : 0;
+        const rows = [
+            ['Total Messages', String(stats.totalMessages)],
+            ['Total LLM Calls', String(stats.totalLLMCalls)],
+            ['Total Tool Uses', String(stats.totalToolUses)],
+            ['Avg Response Time', `${stats.avgResponseTimeMs}ms`],
+            ['Error Rate', `${(errorRate * 100).toFixed(1)}%`],
+            ['Token Usage', `${stats.totalTokens.total} tokens (in: ${stats.totalTokens.input}, out: ${stats.totalTokens.output})`],
+        ];
+        const maxKey = Math.max(...rows.map(([k]) => k.length));
+        for (const [key, val] of rows) {
+            console.log(`  ${color.cyan(key.padEnd(maxKey))}  ${val}`);
+        }
+        console.log();
+    }
+    catch {
+        console.log(`  ${icon.info} No score data yet. Run the agent first.\n`);
+    }
+});
+// ── Daemon commands (start/stop/status) ─────────────────────
+const OPC_DIR = path.resolve('.opc');
+program
+    .command('start')
+    .description('Start agent as a background daemon')
+    .option('-f, --file <file>', 'OAD file (agent.yaml or oad.yaml)')
+    .action(async () => {
+    if (!fs.existsSync(OPC_DIR))
+        fs.mkdirSync(OPC_DIR, { recursive: true });
+    const pidFile = path.join(OPC_DIR, 'agent.pid');
+    // Check if already running
+    if (fs.existsSync(pidFile)) {
+        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+        try {
+            process.kill(pid, 0);
+            console.log(`${icon.warn} Agent already running (PID ${pid}).`);
+            return;
+        }
+        catch { /* stale */ }
+    }
+    // Find daemon entry point
+    const daemonScript = path.join(__dirname, 'daemon.js');
+    if (!fs.existsSync(daemonScript)) {
+        console.error(`${icon.error} Daemon script not found. Run ${color.cyan('npm run build')} first.`);
+        process.exit(1);
+    }
+    const logFile = path.join(OPC_DIR, 'agent.log');
+    const out = fs.openSync(logFile, 'a');
+    const err = fs.openSync(logFile, 'a');
+    const child = (0, child_process_1.spawn)(process.execPath, [daemonScript], {
+        detached: true,
+        stdio: ['ignore', out, err],
+        cwd: process.cwd(),
+        env: process.env,
+    });
+    child.unref();
+    // Wait briefly for PID file
+    await new Promise(r => setTimeout(r, 1000));
+    if (fs.existsSync(pidFile)) {
+        const pid = fs.readFileSync(pidFile, 'utf-8').trim();
+        console.log(`${icon.success} Agent started (PID ${pid})`);
+        console.log(`   ${color.dim('Logs:')} ${logFile}`);
+        console.log(`   ${color.dim('Stop:')} opc stop`);
+    }
+    else {
+        console.log(`${icon.success} Agent starting... (PID ${child.pid})`);
+        console.log(`   ${color.dim('Logs:')} ${logFile}`);
+    }
+});
+program
+    .command('stop')
+    .description('Stop the background daemon')
+    .action(() => {
+    const pidFile = path.join(OPC_DIR, 'agent.pid');
+    if (!fs.existsSync(pidFile)) {
+        console.log(`${icon.info} No running agent found.`);
+        return;
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+    try {
+        // On Windows, process.kill with SIGTERM may not work; use taskkill
+        if (process.platform === 'win32') {
+            const { execSync } = require('child_process');
+            try {
+                execSync(`taskkill /PID ${pid} /T /F`, { stdio: 'ignore' });
+            }
+            catch { /* ignore */ }
+        }
+        else {
+            process.kill(pid, 'SIGTERM');
+        }
+        console.log(`${icon.success} Sent stop signal to PID ${pid}`);
+    }
+    catch {
+        console.log(`${icon.warn} Process ${pid} not found (may have already stopped).`);
+    }
+    try {
+        fs.unlinkSync(pidFile);
+    }
+    catch { /* ignore */ }
+});
+program
+    .command('status')
+    .description('Check daemon status')
+    .action(() => {
+    const pidFile = path.join(OPC_DIR, 'agent.pid');
+    if (!fs.existsSync(pidFile)) {
+        console.log(`\n  Status: ${color.red('stopped')}\n`);
+        return;
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+    let running = false;
+    try {
+        process.kill(pid, 0);
+        running = true;
+    }
+    catch { /* not running */ }
+    if (!running) {
+        console.log(`\n  Status: ${color.red('stopped')} (stale PID file)`);
+        try {
+            fs.unlinkSync(pidFile);
+        }
+        catch { /* ignore */ }
+        console.log();
+        return;
+    }
+    // Uptime
+    const startedFile = path.join(OPC_DIR, 'started');
+    let uptime = '';
+    if (fs.existsSync(startedFile)) {
+        const startedMs = parseInt(fs.readFileSync(startedFile, 'utf-8').trim(), 10);
+        const secs = Math.floor((Date.now() - startedMs) / 1000);
+        const h = Math.floor(secs / 3600);
+        const m = Math.floor((secs % 3600) / 60);
+        const s = secs % 60;
+        uptime = `${h}h ${m}m ${s}s`;
+    }
+    // Agent name from config
+    let agentName = 'unknown';
+    for (const f of ['agent.yaml', 'oad.yaml']) {
+        if (fs.existsSync(f)) {
+            try {
+                const raw = fs.readFileSync(f, 'utf-8');
+                const cfg = yaml.load(raw);
+                if (cfg?.metadata?.name) {
+                    agentName = cfg.metadata.name;
+                    break;
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    console.log(`\n  Status:  ${color.green('running')}`);
+    console.log(`  PID:     ${pid}`);
+    console.log(`  Agent:   ${color.cyan(agentName)}`);
+    if (uptime)
+        console.log(`  Uptime:  ${uptime}`);
+    console.log();
+});
+// ── Jobs commands ────────────────────────────────────────────
+const jobsCmd = program.command('jobs').description('Manage scheduled jobs');
+jobsCmd
+    .command('list', { isDefault: true })
+    .description('List all scheduled jobs')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .action(async (opts) => {
+    const jobs = loadJobsFromConfig(opts.file);
+    if (jobs.length === 0) {
+        console.log(`\n${icon.info} No scheduled jobs defined in config.\n`);
+        return;
+    }
+    console.log(`\n${icon.gear} ${color.bold('Scheduled Jobs')}\n`);
+    for (const job of jobs) {
+        const status = job.enabled ? color.green('enabled') : color.dim('disabled');
+        const next = job.nextRun ? job.nextRun.toLocaleString() : color.dim('N/A');
+        console.log(`  ${color.cyan(job.id.padEnd(20))} ${job.name}`);
+        console.log(`  ${''.padEnd(20)} Schedule: ${color.dim(job.schedule)} | Status: ${status} | Next: ${next}`);
+        console.log();
+    }
+});
+jobsCmd
+    .command('run')
+    .argument('<id>', 'Job ID to run')
+    .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+    .description('Manually trigger a scheduled job')
+    .action(async (id, opts) => {
+    const jobs = loadJobsFromConfig(opts.file);
+    const job = jobs.find(j => j.id === id || j.name === id);
+    if (!job) {
+        console.error(`${icon.error} Job "${id}" not found. Available: ${jobs.map(j => j.id).join(', ')}`);
+        process.exit(1);
+    }
+    console.log(`${icon.info} Running job "${color.bold(job.name)}"...`);
+    console.log(`  Task: ${color.dim(job.task)}`);
+    console.log(`\n${icon.warn} Manual job execution requires a running daemon. Use ${color.cyan('opc start')} first.\n`);
+});
+function loadJobsFromConfig(file) {
+    try {
+        const raw = fs.readFileSync(file, 'utf-8');
+        const config = yaml.load(raw);
+        const jobConfigs = config?.spec?.scheduler?.jobs ?? [];
+        const { parseCron } = require('./core/scheduler');
+        return jobConfigs.map((j, i) => {
+            const id = j.id || j.name?.toLowerCase().replace(/\s+/g, '-') || `job-${i}`;
+            const parsed = parseCron(j.schedule);
+            // Compute next run
+            const now = new Date();
+            let nextRun;
+            const d = new Date(now);
+            d.setSeconds(0, 0);
+            d.setMinutes(d.getMinutes() + 1);
+            for (let k = 0; k < 48 * 60; k++) {
+                const { cronMatches } = require('./core/scheduler');
+                if (cronMatches(parsed, d)) {
+                    nextRun = new Date(d);
+                    break;
+                }
+                d.setMinutes(d.getMinutes() + 1);
+            }
+            return {
+                id,
+                name: j.name || id,
+                schedule: j.schedule,
+                task: j.task || '',
+                enabled: j.enabled !== false,
+                nextRun,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+// ── Skills commands ──────────────────────────────────────────
+const skillsCmd = program.command('skills').description('Manage learned skills');
+skillsCmd
+    .command('list', { isDefault: true })
+    .description('List all learned skills')
+    .option('-d, --dir <dir>', 'Skills directory', '.opc/skills')
+    .action(async (opts) => {
+    const { SkillLearner } = await Promise.resolve().then(() => __importStar(require('./skills/auto-learn')));
+    const learner = new SkillLearner(opts.dir);
+    const skills = await learner.loadLearnedSkills();
+    if (skills.length === 0) {
+        console.log(`\n${icon.info} No learned skills yet.\n`);
+        console.log(`  Skills are auto-created from conversations when learning is enabled.`);
+        console.log(`  Directory: ${color.dim(path.resolve(opts.dir))}\n`);
+        return;
+    }
+    console.log(`\n${icon.gear} ${color.bold('Learned Skills')} (${skills.length})\n`);
+    for (const skill of skills) {
+        console.log(`  ${color.cyan(skill.name.padEnd(24))} ${skill.description}`);
+        console.log(`  ${''.padEnd(24)} v${skill.version} | used ${skill.usageCount}x | trigger: ${color.dim(skill.trigger)}`);
+        console.log();
+    }
+});
+skillsCmd
+    .command('show')
+    .argument('<name>', 'Skill name')
+    .option('-d, --dir <dir>', 'Skills directory', '.opc/skills')
+    .description('Show details of a learned skill')
+    .action(async (name, opts) => {
+    const skillPath = path.join(opts.dir, `${name}.md`);
+    if (!fs.existsSync(skillPath)) {
+        console.error(`${icon.error} Skill "${name}" not found at ${skillPath}`);
+        process.exit(1);
+    }
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    console.log(`\n${content}`);
+});
+skillsCmd
+    .command('remove')
+    .argument('<name>', 'Skill name')
+    .option('-d, --dir <dir>', 'Skills directory', '.opc/skills')
+    .description('Remove a learned skill')
+    .action(async (name, opts) => {
+    const skillPath = path.join(opts.dir, `${name}.md`);
+    if (!fs.existsSync(skillPath)) {
+        console.error(`${icon.error} Skill "${name}" not found.`);
+        process.exit(1);
+    }
+    fs.unlinkSync(skillPath);
+    console.log(`${icon.success} Removed skill "${color.cyan(name)}".`);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map