opc-agent 2.0.0 → 2.0.1

package/dist/telemetry/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * OPC Agent Telemetry — Lightweight OTel-compatible tracing & metrics.
+ * Zero external dependencies. Produces OTLP-compatible JSON.
+ */
+export interface Span {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind: 'internal' | 'client' | 'server';
+    startTime: number;
+    endTime?: number;
+    status: 'ok' | 'error' | 'unset';
+    attributes: Record<string, string | number | boolean>;
+    events: SpanEvent[];
+}
+export interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, string | number | boolean>;
+}
+export interface Metric {
+    name: string;
+    type: 'counter' | 'gauge' | 'histogram';
+    value: number;
+    timestamp: number;
+    labels: Record<string, string>;
+}
+export interface TraceExporter {
+    export(spans: Span[]): Promise<void>;
+}
+export declare function generateTraceId(): string;
+export declare function generateSpanId(): string;
+export declare class Tracer {
+    private spans;
+    private metrics;
+    private maxSpans;
+    private maxMetrics;
+    private exporters;
+    constructor(options?: {
+        maxSpans?: number;
+        maxMetrics?: number;
+    });
+    startSpan(name: string, options?: {
+        parent?: Span;
+        attributes?: Record<string, string | number | boolean>;
+        kind?: Span['kind'];
+    }): Span;
+    endSpan(span: Span, status?: Span['status']): void;
+    addEvent(span: Span, name: string, attributes?: Record<string, string | number | boolean>): void;
+    increment(name: string, value?: number, labels?: Record<string, string>): void;
+    gauge(name: string, value: number, labels?: Record<string, string>): void;
+    histogram(name: string, value: number, labels?: Record<string, string>): void;
+    private addMetric;
+    getSpans(options?: {
+        limit?: number;
+        traceId?: string;
+        name?: string;
+        since?: number;
+    }): Span[];
+    getMetrics(options?: {
+        name?: string;
+        since?: number;
+    }): Metric[];
+    getTrace(traceId: string): Span[];
+    addExporter(exporter: TraceExporter): void;
+    exportOTLP(): object;
+    getStats(): {
+        totalSpans: number;
+        totalTraces: number;
+        avgDuration: number;
+        errorRate: number;
+        spansByName: Record<string, number>;
+        p50Latency: number;
+        p95Latency: number;
+        p99Latency: number;
+    };
+    clear(): void;
+}
+export declare class ConsoleExporter implements TraceExporter {
+    export(spans: Span[]): Promise<void>;
+}
+export declare class FileExporter implements TraceExporter {
+    private filePath;
+    constructor(filePath: string);
+    export(spans: Span[]): Promise<void>;
+}
+export declare class OTLPHttpExporter implements TraceExporter {
+    private endpoint;
+    constructor(endpoint: string);
+    export(spans: Span[]): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * OPC Agent Telemetry — Lightweight OTel-compatible tracing & metrics.
+ * Zero external dependencies. Produces OTLP-compatible JSON.
+ */
+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 });
+exports.OTLPHttpExporter = exports.FileExporter = exports.ConsoleExporter = exports.Tracer = void 0;
+exports.generateTraceId = generateTraceId;
+exports.generateSpanId = generateSpanId;
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+// ─── ID Generation ───────────────────────────────────────────
+function generateTraceId() {
+    return crypto.randomBytes(16).toString('hex'); // 32 hex chars
+}
+function generateSpanId() {
+    return crypto.randomBytes(8).toString('hex'); // 16 hex chars
+}
+// ─── Tracer ──────────────────────────────────────────────────
+class Tracer {
+    spans = [];
+    metrics = [];
+    maxSpans;
+    maxMetrics;
+    exporters = [];
+    constructor(options) {
+        this.maxSpans = options?.maxSpans || 10000;
+        this.maxMetrics = options?.maxMetrics || 50000;
+    }
+    startSpan(name, options) {
+        const span = {
+            traceId: options?.parent?.traceId || generateTraceId(),
+            spanId: generateSpanId(),
+            parentSpanId: options?.parent?.spanId,
+            name,
+            kind: options?.kind || 'internal',
+            startTime: Date.now(),
+            status: 'unset',
+            attributes: options?.attributes ? { ...options.attributes } : {},
+            events: [],
+        };
+        this.spans.push(span);
+        // Evict oldest spans if over limit
+        if (this.spans.length > this.maxSpans) {
+            const excess = this.spans.length - this.maxSpans;
+            this.spans.splice(0, excess);
+        }
+        return span;
+    }
+    endSpan(span, status) {
+        span.endTime = Date.now();
+        span.status = status || 'ok';
+        // Notify exporters
+        for (const exporter of this.exporters) {
+            exporter.export([span]).catch(() => { });
+        }
+    }
+    addEvent(span, name, attributes) {
+        span.events.push({ name, timestamp: Date.now(), attributes });
+    }
+    // ─── Metrics ─────────────────────────────────────────────
+    increment(name, value = 1, labels = {}) {
+        this.addMetric(name, 'counter', value, labels);
+    }
+    gauge(name, value, labels = {}) {
+        this.addMetric(name, 'gauge', value, labels);
+    }
+    histogram(name, value, labels = {}) {
+        this.addMetric(name, 'histogram', value, labels);
+    }
+    addMetric(name, type, value, labels) {
+        this.metrics.push({ name, type, value, timestamp: Date.now(), labels });
+        if (this.metrics.length > this.maxMetrics) {
+            this.metrics.splice(0, this.metrics.length - this.maxMetrics);
+        }
+    }
+    // ─── Query ───────────────────────────────────────────────
+    getSpans(options) {
+        let result = [...this.spans];
+        if (options?.traceId)
+            result = result.filter(s => s.traceId === options.traceId);
+        if (options?.name)
+            result = result.filter(s => s.name === options.name);
+        if (options?.since)
+            result = result.filter(s => s.startTime >= options.since);
+        // Most recent first
+        result.sort((a, b) => b.startTime - a.startTime);
+        if (options?.limit)
+            result = result.slice(0, options.limit);
+        return result;
+    }
+    getMetrics(options) {
+        let result = [...this.metrics];
+        if (options?.name)
+            result = result.filter(m => m.name === options.name);
+        if (options?.since)
+            result = result.filter(m => m.timestamp >= options.since);
+        return result;
+    }
+    getTrace(traceId) {
+        return this.spans.filter(s => s.traceId === traceId).sort((a, b) => a.startTime - b.startTime);
+    }
+    // ─── Export (OTLP-compatible) ────────────────────────────
+    addExporter(exporter) {
+        this.exporters.push(exporter);
+    }
+    exportOTLP() {
+        // OTLP JSON format: https://opentelemetry.io/docs/specs/otlp/
+        const spansByResource = this.spans.filter(s => s.endTime != null);
+        return {
+            resourceSpans: [{
+                    resource: {
+                        attributes: [
+                            { key: 'service.name', value: { stringValue: 'opc-agent' } },
+                        ],
+                    },
+                    scopeSpans: [{
+                            scope: { name: 'opc-telemetry', version: '1.0.0' },
+                            spans: spansByResource.map(s => ({
+                                traceId: s.traceId,
+                                spanId: s.spanId,
+                                parentSpanId: s.parentSpanId || '',
+                                name: s.name,
+                                kind: s.kind === 'server' ? 2 : s.kind === 'client' ? 3 : 1,
+                                startTimeUnixNano: String(s.startTime * 1_000_000),
+                                endTimeUnixNano: String((s.endTime || s.startTime) * 1_000_000),
+                                attributes: Object.entries(s.attributes).map(([key, value]) => ({
+                                    key,
+                                    value: typeof value === 'string' ? { stringValue: value }
+                                        : typeof value === 'number' ? (Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value })
+                                            : { boolValue: value },
+                                })),
+                                events: s.events.map(e => ({
+                                    timeUnixNano: String(e.timestamp * 1_000_000),
+                                    name: e.name,
+                                    attributes: e.attributes ? Object.entries(e.attributes).map(([key, value]) => ({
+                                        key,
+                                        value: typeof value === 'string' ? { stringValue: value }
+                                            : typeof value === 'number' ? { intValue: String(value) }
+                                                : { boolValue: value },
+                                    })) : [],
+                                })),
+                                status: {
+                                    code: s.status === 'ok' ? 1 : s.status === 'error' ? 2 : 0,
+                                },
+                            })),
+                        }],
+                }],
+        };
+    }
+    // ─── Stats ───────────────────────────────────────────────
+    getStats() {
+        const completed = this.spans.filter(s => s.endTime != null);
+        const durations = completed.map(s => s.endTime - s.startTime).sort((a, b) => a - b);
+        const traceIds = new Set(this.spans.map(s => s.traceId));
+        const errors = completed.filter(s => s.status === 'error').length;
+        const spansByName = {};
+        for (const s of this.spans) {
+            spansByName[s.name] = (spansByName[s.name] || 0) + 1;
+        }
+        const percentile = (arr, p) => {
+            if (arr.length === 0)
+                return 0;
+            const idx = Math.ceil(arr.length * p / 100) - 1;
+            return arr[Math.max(0, idx)];
+        };
+        return {
+            totalSpans: this.spans.length,
+            totalTraces: traceIds.size,
+            avgDuration: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+            errorRate: completed.length > 0 ? errors / completed.length : 0,
+            spansByName,
+            p50Latency: percentile(durations, 50),
+            p95Latency: percentile(durations, 95),
+            p99Latency: percentile(durations, 99),
+        };
+    }
+    clear() {
+        this.spans = [];
+        this.metrics = [];
+    }
+}
+exports.Tracer = Tracer;
+// ─── Exporters ───────────────────────────────────────────────
+class ConsoleExporter {
+    async export(spans) {
+        for (const span of spans) {
+            const duration = span.endTime ? `${span.endTime - span.startTime}ms` : 'ongoing';
+            console.log(`[TRACE] ${span.name} (${duration}) [${span.status}] trace=${span.traceId.slice(0, 8)}`);
+        }
+    }
+}
+exports.ConsoleExporter = ConsoleExporter;
+class FileExporter {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async export(spans) {
+        const lines = spans.map(s => JSON.stringify(s)).join('\n') + '\n';
+        fs.appendFileSync(this.filePath, lines);
+    }
+}
+exports.FileExporter = FileExporter;
+class OTLPHttpExporter {
+    endpoint;
+    constructor(endpoint) {
+        this.endpoint = endpoint.replace(/\/$/, '');
+    }
+    async export(spans) {
+        const body = {
+            resourceSpans: [{
+                    resource: {
+                        attributes: [
+                            { key: 'service.name', value: { stringValue: 'opc-agent' } },
+                        ],
+                    },
+                    scopeSpans: [{
+                            scope: { name: 'opc-telemetry', version: '1.0.0' },
+                            spans: spans.filter(s => s.endTime).map(s => ({
+                                traceId: s.traceId,
+                                spanId: s.spanId,
+                                parentSpanId: s.parentSpanId || '',
+                                name: s.name,
+                                kind: s.kind === 'server' ? 2 : s.kind === 'client' ? 3 : 1,
+                                startTimeUnixNano: String(s.startTime * 1_000_000),
+                                endTimeUnixNano: String((s.endTime || s.startTime) * 1_000_000),
+                                attributes: Object.entries(s.attributes).map(([key, value]) => ({
+                                    key,
+                                    value: typeof value === 'string' ? { stringValue: value }
+                                        : typeof value === 'number' ? { intValue: String(value) }
+                                            : { boolValue: value },
+                                })),
+                                status: { code: s.status === 'ok' ? 1 : s.status === 'error' ? 2 : 0 },
+                            })),
+                        }],
+                }],
+        };
+        try {
+            await fetch(`${this.endpoint}/v1/traces`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+        }
+        catch {
+            // Best effort
+        }
+    }
+}
+exports.OTLPHttpExporter = OTLPHttpExporter;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "postbuild": "xcopy /E /I /Y src\\studio-ui dist\\studio-ui",
     "test": "vitest run",
     "dev": "tsc --watch",
     "lint": "tsc --noEmit",
@@ -31,6 +32,7 @@
     "url": "https://github.com/Deepleaper/opc-agent.git"
   },
   "dependencies": {
+    "agent-workstation": "^1.2.1",
     "agentkits": "^0.1.0",
     "commander": "^12.0.0",
     "express": "^4.21.0",
@@ -44,7 +46,7 @@
     "@types/node": "^20.11.0",
     "@types/ws": "^8.18.1",
     "typescript": "^5.5.0",
-    "vitest": "^2.0.0",
-    "vitepress": "^1.5.0"
+    "vitepress": "^1.5.0",
+    "vitest": "^2.0.0"
   }
 }

package/scripts/install.ps1

@@ -0,0 +1,31 @@
+# OPC Agent — Windows installer
+# Usage: irm https://raw.githubusercontent.com/Deepleaper/opc-agent/main/scripts/install.ps1 | iex
+
+Write-Host "🤖 Installing OPC Agent..." -ForegroundColor Cyan
+
+# Check Node.js
+if (-not (Get-Command node -ErrorAction SilentlyContinue)) {
+    Write-Host "❌ Node.js is required. Install from https://nodejs.org (v18+)" -ForegroundColor Red
+    exit 1
+}
+
+$nodeVer = (node -v) -replace 'v','' -split '\.' | Select-Object -First 1
+if ([int]$nodeVer -lt 18) {
+    Write-Host "❌ Node.js 18+ required (found $(node -v))" -ForegroundColor Red
+    exit 1
+}
+
+Write-Host "📦 Installing opc-agent globally..."
+npm install -g opc-agent
+
+Write-Host "`n✅ OPC Agent installed!" -ForegroundColor Green
+Write-Host @"
+
+Quick start:
+  opc init my-agent
+  cd my-agent
+  npm install
+  opc chat
+
+Run 'opc doctor' to check your environment.
+"@

package/scripts/install.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# OPC Agent — One-line installer
+# Usage: curl -fsSL https://raw.githubusercontent.com/Deepleaper/opc-agent/main/scripts/install.sh | bash
+
+set -e
+
+echo "🤖 Installing OPC Agent..."
+
+# Check Node.js
+if ! command -v node &> /dev/null; then
+    echo "❌ Node.js is required. Install from https://nodejs.org (v18+)"
+    exit 1
+fi
+
+NODE_VERSION=$(node -v | sed 's/v//' | cut -d. -f1)
+if [ "$NODE_VERSION" -lt 18 ]; then
+    echo "❌ Node.js 18+ required (found v$(node -v))"
+    exit 1
+fi
+
+# Install globally
+echo "📦 Installing opc-agent globally..."
+npm install -g opc-agent
+
+# Verify
+if command -v opc &> /dev/null; then
+    echo ""
+    echo "✅ OPC Agent installed successfully!"
+    echo ""
+    echo "Quick start:"
+    echo "  opc init my-agent"
+    echo "  cd my-agent"
+    echo "  npm install"
+    echo "  opc chat"
+    echo ""
+    echo "Run 'opc doctor' to check your environment."
+else
+    echo "⚠️  Installed but 'opc' command not found in PATH."
+    echo "Try: npx opc-agent --help"
+fi