opc-agent 1.4.0 → 2.0.1

package/dist/core/subagent.d.ts

@@ -0,0 +1,28 @@
+export interface SubAgentConfig {
+    name: string;
+    task: string;
+    systemPrompt?: string;
+    provider?: string;
+    model?: string;
+    timeout?: number;
+    isolated?: boolean;
+}
+export interface SubAgentResult {
+    id: string;
+    name: string;
+    status: 'completed' | 'failed' | 'timeout';
+    result: string;
+    duration: number;
+}
+export declare class SubAgentManager {
+    private agents;
+    spawn(config: SubAgentConfig, parentProvider?: any): Promise<SubAgentResult>;
+    spawnParallel(configs: SubAgentConfig[], parentProvider?: any): Promise<SubAgentResult[]>;
+    list(): Array<{
+        id: string;
+        name: string;
+        status: string;
+    }>;
+    kill(id: string): boolean;
+}
+//# sourceMappingURL=subagent.d.ts.map

package/dist/core/subagent.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubAgentManager = void 0;
+const agent_1 = require("./agent");
+const memory_1 = require("../memory");
+class SubAgentManager {
+    agents = new Map();
+    async spawn(config, parentProvider) {
+        const id = `sub_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const timeout = config.timeout ?? 300000;
+        const isolated = config.isolated !== false;
+        const agent = new agent_1.BaseAgent({
+            name: config.name,
+            systemPrompt: config.systemPrompt ?? 'You are a helpful sub-agent.',
+            provider: config.provider ?? 'openai',
+            model: config.model,
+            memory: isolated ? new memory_1.InMemoryStore() : undefined,
+        });
+        this.agents.set(id, { agent, status: 'running', name: config.name });
+        const message = {
+            id: `msg_${Date.now()}`,
+            role: 'user',
+            content: config.task,
+            timestamp: Date.now(),
+            metadata: { subAgentId: id },
+        };
+        const start = Date.now();
+        try {
+            const result = await Promise.race([
+                agent.handleMessage(message),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('SubAgent timeout')), timeout)),
+            ]);
+            const duration = Date.now() - start;
+            this.agents.set(id, { agent, status: 'completed', name: config.name });
+            return { id, name: config.name, status: 'completed', result: result.content, duration };
+        }
+        catch (err) {
+            const duration = Date.now() - start;
+            const isTimeout = err.message.includes('timeout');
+            const status = isTimeout ? 'timeout' : 'failed';
+            this.agents.set(id, { agent, status, name: config.name });
+            return { id, name: config.name, status, result: err.message, duration };
+        }
+    }
+    async spawnParallel(configs, parentProvider) {
+        return Promise.all(configs.map((c) => this.spawn(c, parentProvider)));
+    }
+    list() {
+        return Array.from(this.agents.entries()).map(([id, entry]) => ({
+            id,
+            name: entry.name,
+            status: entry.status,
+        }));
+    }
+    kill(id) {
+        const entry = this.agents.get(id);
+        if (!entry)
+            return false;
+        entry.status = 'killed';
+        this.agents.set(id, entry);
+        return true;
+    }
+}
+exports.SubAgentManager = SubAgentManager;
+//# sourceMappingURL=subagent.js.map

package/dist/core/workflow-graph.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Graph-based Workflow Engine with conditional branching, parallel execution,
+ * loops, retry, timeout, and error handling.
+ *
+ * This is a standalone engine that works with function-based steps (no skill/agent coupling).
+ * The original WorkflowEngine in workflow.ts is preserved for backward compatibility.
+ */
+export interface WorkflowContext {
+    variables: Map<string, any>;
+    results: Map<string, any>;
+    currentStep: string;
+    startTime: Date;
+    errors: Array<{
+        step: string;
+        error: Error;
+    }>;
+}
+export interface GraphWorkflowStep {
+    id: string;
+    name: string;
+    type: 'action' | 'condition' | 'parallel' | 'loop';
+    action?: (context: WorkflowContext) => Promise<any>;
+    condition?: (context: WorkflowContext) => boolean;
+    onTrue?: string;
+    onFalse?: string;
+    parallel?: string[];
+    loopCondition?: (context: WorkflowContext) => boolean;
+    loopBody?: string;
+    maxIterations?: number;
+    next?: string;
+    retryCount?: number;
+    retryDelay?: number;
+    timeout?: number;
+    onError?: 'stop' | 'skip' | 'retry';
+}
+export interface GraphWorkflow {
+    name: string;
+    entryPoint: string;
+    steps: Map<string, GraphWorkflowStep>;
+}
+export interface GraphWorkflowResult {
+    workflow: string;
+    status: 'completed' | 'failed';
+    context: WorkflowContext;
+    totalDurationMs: number;
+}
+export declare class GraphWorkflowEngine {
+    execute(workflow: GraphWorkflow): Promise<GraphWorkflowResult>;
+    private executeAction;
+    private executeParallel;
+    private executeLoop;
+}
+export declare class WorkflowBuilder {
+    private steps;
+    private entry;
+    private workflowName;
+    name(n: string): this;
+    start(id: string): this;
+    addAction(id: string, action: (context: WorkflowContext) => Promise<any>, options?: Partial<GraphWorkflowStep>): this;
+    addCondition(id: string, condition: (context: WorkflowContext) => boolean, onTrue: string, onFalse: string, options?: Partial<GraphWorkflowStep>): this;
+    addParallel(id: string, stepIds: string[], next?: string, options?: Partial<GraphWorkflowStep>): this;
+    addLoop(id: string, condition: (context: WorkflowContext) => boolean, body: string, options?: {
+        maxIterations?: number;
+        next?: string;
+        name?: string;
+    }): this;
+    build(): GraphWorkflow;
+}
+export interface OADWorkflowStepDef {
+    id: string;
+    type: 'action' | 'condition' | 'parallel' | 'loop';
+    name?: string;
+    next?: string;
+    onTrue?: string;
+    onFalse?: string;
+    parallel?: string[];
+    loopBody?: string;
+    maxIterations?: number;
+    retryCount?: number;
+    retryDelay?: number;
+    timeout?: number;
+    onError?: 'stop' | 'skip' | 'retry';
+}
+export interface OADWorkflowDef {
+    name: string;
+    steps: OADWorkflowStepDef[];
+}
+/**
+ * Parse an OAD workflow definition into a GraphWorkflow.
+ * Action handlers must be supplied via the actionMap.
+ */
+export declare function parseOADWorkflow(def: OADWorkflowDef, actionMap?: Map<string, (context: WorkflowContext) => Promise<any>>, conditionMap?: Map<string, (context: WorkflowContext) => boolean>): GraphWorkflow;
+//# sourceMappingURL=workflow-graph.d.ts.map

package/dist/core/workflow-graph.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Graph-based Workflow Engine with conditional branching, parallel execution,
+ * loops, retry, timeout, and error handling.
+ *
+ * This is a standalone engine that works with function-based steps (no skill/agent coupling).
+ * The original WorkflowEngine in workflow.ts is preserved for backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowBuilder = exports.GraphWorkflowEngine = void 0;
+exports.parseOADWorkflow = parseOADWorkflow;
+// ── Helpers ─────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function rejectAfter(ms) {
+    return new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms));
+}
+function neverResolve() {
+    return new Promise(() => { });
+}
+function createContext() {
+    return {
+        variables: new Map(),
+        results: new Map(),
+        currentStep: '',
+        startTime: new Date(),
+        errors: [],
+    };
+}
+// ── Graph Workflow Engine ───────────────────────────────────
+class GraphWorkflowEngine {
+    async execute(workflow) {
+        const startTime = Date.now();
+        const context = createContext();
+        let currentStep = workflow.entryPoint;
+        try {
+            while (currentStep) {
+                const step = workflow.steps.get(currentStep);
+                if (!step)
+                    break;
+                context.currentStep = step.id;
+                switch (step.type) {
+                    case 'action':
+                        await this.executeAction(step, context, workflow);
+                        currentStep = step.next;
+                        break;
+                    case 'condition':
+                        if (!step.condition)
+                            throw new Error(`Step "${step.id}" missing condition function`);
+                        const result = step.condition(context);
+                        currentStep = result ? step.onTrue : step.onFalse;
+                        break;
+                    case 'parallel':
+                        await this.executeParallel(step, context, workflow);
+                        currentStep = step.next;
+                        break;
+                    case 'loop':
+                        await this.executeLoop(step, context, workflow);
+                        currentStep = step.next;
+                        break;
+                    default:
+                        currentStep = step.next;
+                }
+            }
+        }
+        catch (err) {
+            // Error already recorded in context.errors by executeAction
+        }
+        return {
+            workflow: workflow.name,
+            status: context.errors.length > 0 ? 'failed' : 'completed',
+            context,
+            totalDurationMs: Date.now() - startTime,
+        };
+    }
+    async executeAction(step, context, _workflow) {
+        if (!step.action) {
+            context.results.set(step.id, undefined);
+            return;
+        }
+        let attempts = 0;
+        const maxAttempts = (step.retryCount ?? 0) + 1;
+        const errorPolicy = step.onError ?? 'stop';
+        while (attempts < maxAttempts) {
+            try {
+                const promises = [step.action(context)];
+                if (step.timeout)
+                    promises.push(rejectAfter(step.timeout));
+                else
+                    promises.push(neverResolve());
+                const result = await Promise.race(promises);
+                context.results.set(step.id, result);
+                return;
+            }
+            catch (e) {
+                attempts++;
+                if (attempts >= maxAttempts) {
+                    if (errorPolicy === 'skip') {
+                        context.results.set(step.id, undefined);
+                        return;
+                    }
+                    const error = e instanceof Error ? e : new Error(String(e));
+                    context.errors.push({ step: step.id, error });
+                    if (errorPolicy === 'stop')
+                        throw error;
+                    return;
+                }
+                if (step.retryDelay)
+                    await sleep(step.retryDelay);
+            }
+        }
+    }
+    async executeParallel(step, context, workflow) {
+        if (!step.parallel || step.parallel.length === 0)
+            return;
+        const tasks = step.parallel.map(async (stepId) => {
+            const subStep = workflow.steps.get(stepId);
+            if (!subStep)
+                throw new Error(`Parallel step "${stepId}" not found`);
+            if (subStep.type === 'action') {
+                await this.executeAction(subStep, context, workflow);
+            }
+        });
+        await Promise.all(tasks);
+    }
+    async executeLoop(step, context, workflow) {
+        if (!step.loopCondition || !step.loopBody)
+            return;
+        const max = step.maxIterations ?? 100;
+        let iterations = 0;
+        while (step.loopCondition(context) && iterations < max) {
+            const bodyStep = workflow.steps.get(step.loopBody);
+            if (!bodyStep)
+                break;
+            if (bodyStep.type === 'action') {
+                await this.executeAction(bodyStep, context, workflow);
+            }
+            iterations++;
+        }
+        context.results.set(step.id, { iterations });
+    }
+}
+exports.GraphWorkflowEngine = GraphWorkflowEngine;
+// ── Workflow Builder ────────────────────────────────────────
+class WorkflowBuilder {
+    steps = new Map();
+    entry = '';
+    workflowName = 'unnamed';
+    name(n) {
+        this.workflowName = n;
+        return this;
+    }
+    start(id) {
+        this.entry = id;
+        return this;
+    }
+    addAction(id, action, options) {
+        this.steps.set(id, {
+            id,
+            name: options?.name ?? id,
+            type: 'action',
+            action,
+            ...options,
+        });
+        return this;
+    }
+    addCondition(id, condition, onTrue, onFalse, options) {
+        this.steps.set(id, {
+            id,
+            name: options?.name ?? id,
+            type: 'condition',
+            condition,
+            onTrue,
+            onFalse,
+            ...options,
+        });
+        return this;
+    }
+    addParallel(id, stepIds, next, options) {
+        this.steps.set(id, {
+            id,
+            name: options?.name ?? id,
+            type: 'parallel',
+            parallel: stepIds,
+            next,
+            ...options,
+        });
+        return this;
+    }
+    addLoop(id, condition, body, options) {
+        this.steps.set(id, {
+            id,
+            name: options?.name ?? id,
+            type: 'loop',
+            loopCondition: condition,
+            loopBody: body,
+            maxIterations: options?.maxIterations,
+            next: options?.next,
+        });
+        return this;
+    }
+    build() {
+        if (!this.entry)
+            throw new Error('Workflow must have an entry point. Call start() first.');
+        return {
+            name: this.workflowName,
+            entryPoint: this.entry,
+            steps: new Map(this.steps),
+        };
+    }
+}
+exports.WorkflowBuilder = WorkflowBuilder;
+/**
+ * Parse an OAD workflow definition into a GraphWorkflow.
+ * Action handlers must be supplied via the actionMap.
+ */
+function parseOADWorkflow(def, actionMap = new Map(), conditionMap = new Map()) {
+    const steps = new Map();
+    for (const s of def.steps) {
+        const step = {
+            id: s.id,
+            name: s.name ?? s.id,
+            type: s.type,
+            next: s.next,
+            onTrue: s.onTrue,
+            onFalse: s.onFalse,
+            parallel: s.parallel,
+            loopBody: s.loopBody,
+            maxIterations: s.maxIterations,
+            retryCount: s.retryCount,
+            retryDelay: s.retryDelay,
+            timeout: s.timeout,
+            onError: s.onError,
+        };
+        if (s.type === 'action') {
+            step.action = actionMap.get(s.id);
+        }
+        if (s.type === 'condition') {
+            step.condition = conditionMap.get(s.id);
+        }
+        steps.set(s.id, step);
+    }
+    const entryPoint = def.steps[0]?.id ?? '';
+    return { name: def.name, entryPoint, steps };
+}
+//# sourceMappingURL=workflow-graph.js.map

package/dist/daemon.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=daemon.d.ts.map

package/dist/daemon.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Daemon entry point — spawned by `opc start` as a detached background process.
+ * Loads agent.yaml, creates runtime, starts all channels, writes heartbeat.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("./core/runtime");
+const OPC_DIR = path.resolve('.opc');
+const HEARTBEAT_FILE = path.join(OPC_DIR, 'heartbeat');
+const LOG_FILE = path.join(OPC_DIR, 'agent.log');
+const PID_FILE = path.join(OPC_DIR, 'agent.pid');
+const HEARTBEAT_INTERVAL = 30_000;
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+function log(msg) {
+    const line = `[${new Date().toISOString()}] ${msg}\n`;
+    try {
+        fs.appendFileSync(LOG_FILE, line);
+    }
+    catch { /* ignore */ }
+}
+async function main() {
+    ensureDir(OPC_DIR);
+    // Redirect stdout/stderr to log file
+    const logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
+    process.stdout.write = logStream.write.bind(logStream);
+    process.stderr.write = logStream.write.bind(logStream);
+    // Write PID
+    fs.writeFileSync(PID_FILE, String(process.pid));
+    log(`Daemon started, PID=${process.pid}`);
+    // Write start time for uptime calculation
+    fs.writeFileSync(path.join(OPC_DIR, 'started'), String(Date.now()));
+    // Heartbeat
+    const heartbeatTimer = setInterval(() => {
+        try {
+            fs.writeFileSync(HEARTBEAT_FILE, String(Date.now()));
+        }
+        catch { /* ignore */ }
+    }, HEARTBEAT_INTERVAL);
+    fs.writeFileSync(HEARTBEAT_FILE, String(Date.now()));
+    // Load .env
+    const envPath = path.resolve('.env');
+    if (fs.existsSync(envPath)) {
+        try {
+            const content = fs.readFileSync(envPath, 'utf-8');
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const eqIdx = trimmed.indexOf('=');
+                if (eqIdx === -1)
+                    continue;
+                const key = trimmed.slice(0, eqIdx).trim();
+                const value = trimmed.slice(eqIdx + 1).trim();
+                if (!process.env[key])
+                    process.env[key] = value;
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // Determine config file
+    const configFile = fs.existsSync('agent.yaml') ? 'agent.yaml' : 'oad.yaml';
+    const runtime = new runtime_1.AgentRuntime();
+    await runtime.loadConfig(configFile);
+    await runtime.initialize();
+    await runtime.start();
+    log(`Agent running (config=${configFile})`);
+    // Graceful shutdown
+    const shutdown = async (signal) => {
+        log(`Received ${signal}, shutting down...`);
+        clearInterval(heartbeatTimer);
+        await runtime.stop();
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch { /* ignore */ }
+        log('Daemon stopped');
+        process.exit(0);
+    };
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    // On Windows, handle the message-based kill
+    process.on('message', (msg) => {
+        if (msg === 'shutdown')
+            shutdown('message:shutdown');
+    });
+}
+main().catch((err) => {
+    log(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+    try {
+        fs.unlinkSync(PID_FILE);
+    }
+    catch { /* ignore */ }
+    process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map

package/dist/doctor.d.ts

@@ -0,0 +1,15 @@
+export interface CheckResult {
+    ok: boolean;
+    detail: string;
+    fix?: string;
+}
+export interface DoctorCheck {
+    name: string;
+    check: () => CheckResult | Promise<CheckResult>;
+}
+export declare function getDoctorChecks(): DoctorCheck[];
+export declare function runDoctor(): Promise<{
+    passed: number;
+    total: number;
+}>;
+//# sourceMappingURL=doctor.d.ts.map