@crewx/sdk 0.8.0-rc.78 → 0.8.0-rc.80

package/dist/esm/parsers/gemini.parser.js

@@ -1,43 +0,0 @@
-import { isAgentCallCommand, parseAgentCall } from './agent-call.util';
-/**
- * Parse Gemini stream-json events into TaskLogEntry[].
- *
- * Gemini events:
- * - { type: "message", role: "assistant", delta: true, content: "..." }
- * - { type: "init", ... } (ignored)
- * - { type: "tool_use", tool_name, tool_id, parameters }
- * - { type: "tool_result", tool_id, status, output }
- */
-export function parseGeminiEvent(timestamp, parsed) {
-    const type = parsed.type;
-    if (type === 'message') {
-        const role = parsed.role;
-        if (role !== 'assistant')
-            return [];
-        const content = parsed.content;
-        if (!content)
-            return [];
-        return [{ timestamp, type: 'text', content }];
-    }
-    if (type === 'tool_use') {
-        const toolName = String(parsed.tool_name || '');
-        const toolUseId = parsed.tool_id;
-        const parameters = parsed.parameters;
-        const inputStr = parameters?.command
-            ? String(parameters.command)
-            : JSON.stringify(parameters || {});
-        if (/^bash$/i.test(toolName) && isAgentCallCommand(inputStr)) {
-            return [parseAgentCall(timestamp, inputStr)];
-        }
-        return [{ timestamp, type: 'tool_use', toolName, toolUseId, toolInput: inputStr }];
-    }
-    if (type === 'tool_result') {
-        const toolUseId = parsed.tool_id;
-        const output = String(parsed.output || '');
-        const isError = parsed.status !== 'success';
-        return [{ timestamp, type: 'tool_result', toolUseId, resultPreview: output, isError }];
-    }
-    // init and other events: skip
-    return [];
-}
-//# sourceMappingURL=gemini.parser.js.map

package/dist/esm/parsers/opencode.parser.js

@@ -1,73 +0,0 @@
-/**
- * Parse OpenCode stream-json events (--format json) into TaskLogEntry[].
- *
- * OpenCode events:
- * - { type: "step_start", sessionID: "ses_...", part: { type: "step-start" } }
- * - { type: "text", part: { type: "text", text: "..." } }
- * - { type: "step_finish", part: { reason: "stop", tokens: { total, input, output, reasoning, cache: { write, read } }, cost: 0 } }
- * - { type: "tool_use", part: { type: "tool", tool: "bash"|"write"|..., callID: "...", state: { status, input, output } } }
- */
-export function parseOpencodeEvent(timestamp, parsed) {
-    const type = parsed.type;
-    if (type === 'text') {
-        const part = parsed.part;
-        const text = part?.text;
-        if (!text)
-            return [];
-        return [{ timestamp, type: 'text', content: text }];
-    }
-    if (type === 'tool_use') {
-        const part = parsed.part;
-        if (!part)
-            return [];
-        const tool = String(part.tool || '');
-        const toolUseId = String(part.callID || '');
-        const state = part.state;
-        const status = String(state?.status || '');
-        const input = state?.input;
-        const inputStr = extractToolInput(input);
-        const entries = [
-            { timestamp, type: 'tool_use', toolName: tool, toolUseId, toolInput: inputStr },
-        ];
-        if (status === 'completed' && state?.output !== undefined) {
-            const output = state.output;
-            const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
-            entries.push({ timestamp, type: 'tool_result', toolUseId, resultPreview: outputStr, isError: false });
-        }
-        else if (status === 'error') {
-            entries.push({
-                timestamp,
-                type: 'tool_result',
-                toolUseId,
-                resultPreview: String(state?.error || 'tool error'),
-                isError: true,
-            });
-        }
-        return entries;
-    }
-    // step_start, step_finish: skip (usage is extracted by parse-usage.ts)
-    return [];
-}
-/**
- * Extract a human-friendly string from OpenCode tool input.
- *
- * Matches Claude/Gemini parser behaviour:
- *  - bash-like  → input.command   ("mkdir -p /tmp/foo")
- *  - file tools → input.filePath  ("/tmp/foo/bar.ts")
- *  - otherwise  → JSON.stringify fallback
- */
-function extractToolInput(input) {
-    if (typeof input === 'string')
-        return input;
-    if (!input || typeof input !== 'object')
-        return JSON.stringify(input ?? {});
-    const obj = input;
-    if (obj.command)
-        return String(obj.command);
-    if (obj.filePath)
-        return String(obj.filePath);
-    if (obj.pattern)
-        return String(obj.pattern);
-    return JSON.stringify(obj);
-}
-//# sourceMappingURL=opencode.parser.js.map

package/dist/esm/parsers/router.js

@@ -1,53 +0,0 @@
-/**
- * parseStdoutEvent — routes a single stdout JSONL event to the appropriate provider parser.
- * Returns TaskLogEntry[] (may be empty if event is not recognized or irrelevant).
- */
-import { parseClaudeEvent } from './claude.parser';
-import { parseCopilotEvent } from './copilot.parser';
-import { parseCodexEvent } from './codex.parser';
-import { parseGeminiEvent } from './gemini.parser';
-import { parseOpencodeEvent } from './opencode.parser';
-export function parseStdoutEvent(timestamp, message) {
-    let parsed;
-    try {
-        parsed = JSON.parse(message);
-    }
-    catch {
-        return [];
-    }
-    const type = parsed.type;
-    if (!type)
-        return [];
-    // Claude stream-json (system event excluded — meta event)
-    if (type === 'assistant' || type === 'user') {
-        return parseClaudeEvent(timestamp, parsed);
-    }
-    // Copilot json — assistant.* check must precede Gemini "message" check
-    if (type.startsWith('tool.execution') || type.startsWith('assistant.') || type === 'user.message') {
-        return parseCopilotEvent(timestamp, parsed);
-    }
-    // Codex experimental-json
-    if (type.startsWith('item.') || type.startsWith('turn.') || type.startsWith('thread.')) {
-        return parseCodexEvent(timestamp, parsed);
-    }
-    // Gemini stream-json — tool_use/tool_result routed by structure below
-    if (type === 'message' || type === 'init') {
-        return parseGeminiEvent(timestamp, parsed);
-    }
-    // tool_use / tool_result: disambiguate by schema structure.
-    // OpenCode has a `part` object; Gemini is flat (tool_name, parameters).
-    if (type === 'tool_use' || type === 'tool_result') {
-        if (parsed.part && typeof parsed.part === 'object') {
-            return parseOpencodeEvent(timestamp, parsed);
-        }
-        return parseGeminiEvent(timestamp, parsed);
-    }
-    // OpenCode stream-json (--format json)
-    // Note: 'text' is a generic name but not used by any other provider currently.
-    // 'step_start' and 'step_finish' are OpenCode-specific.
-    if (type === 'text' || type === 'step_start' || type === 'step_finish') {
-        return parseOpencodeEvent(timestamp, parsed);
-    }
-    return [];
-}
-//# sourceMappingURL=router.js.map

package/dist/esm/platform/BrowserFsAdapter.js

@@ -1,80 +0,0 @@
-/**
- * BrowserFsAdapter — IFsAdapter implementation for browser environments.
- *
- * Uses localStorage as the backing store with a key-prefix namespace.
- * Paths are normalized to forward-slash POSIX style.
- *
- * Usage:
- *   const fs = new BrowserFsAdapter();
- *   // Pre-load content before using with DocumentLoader:
- *   fs.setItem('/docs/guide.md', '# Guide\n...');
- */
-const DEFAULT_PREFIX = 'crewx:fs:';
-export class BrowserFsAdapter {
-    prefix;
-    store;
-    /**
-     * @param options.prefix - localStorage key prefix (default: 'crewx:fs:')
-     * @param options.storage - optional external storage map (defaults to an in-memory Map;
-     *                          pass a localStorage-backed wrapper for persistence)
-     */
-    constructor(options) {
-        this.prefix = options?.prefix ?? DEFAULT_PREFIX;
-        this.store = options?.storage ?? new Map();
-    }
-    async readFile(path) {
-        const key = this.toKey(path);
-        const content = this.store.get(key);
-        if (content === undefined) {
-            throw new Error(`BrowserFsAdapter: file not found: ${path}`);
-        }
-        return content;
-    }
-    async exists(path) {
-        return this.store.has(this.toKey(path));
-    }
-    resolvePath(...segments) {
-        // Simple POSIX-style path joining (no true "resolve" since there's no cwd)
-        const joined = segments
-            .map(s => s.replace(/\\/g, '/'))
-            .join('/')
-            .replace(/\/+/g, '/');
-        // Normalize . and .. segments
-        const parts = joined.split('/');
-        const resolved = [];
-        for (const part of parts) {
-            if (part === '.' || part === '')
-                continue;
-            if (part === '..') {
-                resolved.pop();
-            }
-            else {
-                resolved.push(part);
-            }
-        }
-        const result = resolved.join('/');
-        return joined.startsWith('/') ? `/${result}` : result;
-    }
-    isAbsolute(path) {
-        return path.startsWith('/');
-    }
-    // ── Browser-specific helpers ───────────────────────────────────────────────
-    /** Store a virtual file for later reading. */
-    setItem(path, content) {
-        this.store.set(this.toKey(path), content);
-    }
-    /** Remove a virtual file. */
-    removeItem(path) {
-        this.store.delete(this.toKey(path));
-    }
-    /** List all stored virtual file paths. */
-    keys() {
-        return Array.from(this.store.keys())
-            .filter(k => k.startsWith(this.prefix))
-            .map(k => k.slice(this.prefix.length));
-    }
-    toKey(path) {
-        return `${this.prefix}${path.replace(/\\/g, '/')}`;
-    }
-}
-//# sourceMappingURL=BrowserFsAdapter.js.map

package/dist/esm/platform/IFsAdapter.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=IFsAdapter.js.map

package/dist/esm/platform/NodeFsAdapter.js

@@ -1,34 +0,0 @@
-/**
- * NodeFsAdapter — default IFsAdapter implementation using Node.js fs/path.
- *
- * This is the concrete adapter used in CLI and server contexts.
- * Full platform abstraction (WEB, browser) is deferred to a future round.
- */
-import { readFile, access } from 'fs/promises';
-import { resolve, join, isAbsolute } from 'path';
-export class NodeFsAdapter {
-    async readFile(path) {
-        return readFile(path, 'utf-8');
-    }
-    async exists(path) {
-        try {
-            await access(path);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    resolvePath(...segments) {
-        if (segments.length === 1) {
-            return resolve(segments[0]);
-        }
-        return resolve(join(...segments));
-    }
-    isAbsolute(path) {
-        return isAbsolute(path);
-    }
-}
-/** Singleton default adapter for convenience in CLI usage. */
-export const defaultFsAdapter = new NodeFsAdapter();
-//# sourceMappingURL=NodeFsAdapter.js.map

package/dist/esm/plugin/plugin-provider.js

@@ -1,202 +0,0 @@
-/**
- * Plugin Provider Runtime
- *
- * Implements ProviderRuntime for `type: plugin` providers in crewx.yaml.
- * Wraps an arbitrary CLI tool as a CrewX agent via child_process.spawn (shell: false).
- *
- * Symmetric to remote/remote-provider.ts — registered as the `plugin` namespace factory.
- */
-import { spawn } from 'child_process';
-import { ProviderError } from '../provider/bridge.js';
-/**
- * ProviderRuntime implementation for plugin (CLI-wrapped) providers.
- *
- * Created by the `plugin` namespace factory when `createProvider('plugin/mock')` is called.
- * Spawns the configured CLI with args derived from query_args/execute_args,
- * applies `{model}` substitution, and routes the prompt via args or stdin.
- */
-export class PluginProviderRuntime {
-    config;
-    providerStr;
-    constructor(id, config) {
-        this.config = config;
-        this.providerStr = `plugin/${id}`;
-        // Validate at construction time (fail early, not at call time)
-        validateCliCommand(config.cli_command);
-        validateCliArgs(config.query_args);
-        validateCliArgs(config.execute_args);
-        if (config.error_patterns)
-            validateErrorPatterns(config.error_patterns);
-        if (config.env)
-            validateEnv(config.env);
-    }
-    async query(message, options) {
-        const model = options?.model ?? this.config.default_model ?? 'default';
-        const args = resolveArgs(this.config.query_args, model, message, this.config.prompt_in_args);
-        const stdinMessage = this.config.prompt_in_args ? undefined : message;
-        options?.onCommand?.(`${this.config.cli_command} ${args.join(' ')}`);
-        const timeoutMs = this.config.timeout?.query ?? 600000;
-        return this.runProcess(args, options, stdinMessage, timeoutMs);
-    }
-    async execute(message, options) {
-        const model = options?.model ?? this.config.default_model ?? 'default';
-        const args = resolveArgs(this.config.execute_args, model, message, this.config.prompt_in_args);
-        const stdinMessage = this.config.prompt_in_args ? undefined : message;
-        options?.onCommand?.(`${this.config.cli_command} ${args.join(' ')}`);
-        const timeoutMs = this.config.timeout?.execute ?? 600000;
-        return this.runProcess(args, options, stdinMessage, timeoutMs);
-    }
-    runProcess(args, options, stdinMessage, timeoutMs) {
-        return new Promise((resolve, reject) => {
-            // Merge env: process.env is the base; config.env values are added on top.
-            // Never replaces process.env — only extends it.
-            const mergedEnv = {
-                ...process.env,
-                ...(this.config.env ?? {}),
-            };
-            const proc = spawn(this.config.cli_command, args, {
-                env: mergedEnv,
-                shell: false, // Security: no shell interpolation
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            // Write prompt to stdin when prompt_in_args is false
-            if (stdinMessage !== undefined) {
-                proc.stdin.write(stdinMessage);
-                proc.stdin.end();
-            }
-            else {
-                proc.stdin.end();
-            }
-            if (proc.pid !== undefined) {
-                options?.onPid?.(proc.pid);
-            }
-            let stdout = '';
-            let stderr = '';
-            let stdoutBuf = '';
-            let stderrBuf = '';
-            proc.stdout.on('data', (chunk) => {
-                const str = chunk.toString();
-                stdout += str;
-                stdoutBuf += str;
-                const lines = stdoutBuf.split('\n');
-                stdoutBuf = lines.pop() ?? '';
-                for (const line of lines) {
-                    if (line.trim())
-                        options?.onOutput?.(line, 'stdout');
-                }
-            });
-            proc.stderr.on('data', (chunk) => {
-                const str = chunk.toString();
-                stderr += str;
-                stderrBuf += str;
-                const lines = stderrBuf.split('\n');
-                stderrBuf = lines.pop() ?? '';
-                for (const line of lines) {
-                    if (line.trim())
-                        options?.onOutput?.(line, 'stderr');
-                }
-            });
-            // Hard timeout — terminate and reject if exceeded
-            const timeoutHandle = setTimeout(() => {
-                proc.kill('SIGTERM');
-                reject(new ProviderError(`Plugin provider "${this.providerStr}" timed out after ${timeoutMs}ms`, this.providerStr));
-            }, timeoutMs);
-            proc.on('error', (err) => {
-                clearTimeout(timeoutHandle);
-                if (err.code === 'ENOENT') {
-                    const hint = this.config.not_installed_message
-                        ?? `CLI command "${this.config.cli_command}" not found. Is ${this.config.id} installed?`;
-                    reject(new ProviderError(hint, this.providerStr));
-                }
-                else {
-                    reject(new ProviderError(`Spawn error: ${err.message}`, this.providerStr));
-                }
-            });
-            proc.on('close', (code) => {
-                clearTimeout(timeoutHandle);
-                // Flush residual buffered content (no trailing newline)
-                if (stdoutBuf.trim())
-                    options?.onOutput?.(stdoutBuf, 'stdout');
-                if (stderrBuf.trim())
-                    options?.onOutput?.(stderrBuf, 'stderr');
-                const exitCode = code ?? 0;
-                options?.onExitCode?.(exitCode);
-                // Check configured error patterns before exit code
-                if (this.config.error_patterns) {
-                    const combined = stderr || stdout;
-                    for (const ep of this.config.error_patterns) {
-                        if (combined.includes(ep.pattern)) {
-                            reject(new ProviderError(ep.message, this.providerStr));
-                            return;
-                        }
-                    }
-                }
-                if (code !== 0) {
-                    reject(new ProviderError(`Process exited with code ${code}: ${stderr.slice(0, 500)}`, this.providerStr));
-                    return;
-                }
-                resolve(stdout.trim());
-            });
-        });
-    }
-}
-// ── Factory ─────────────────────────────────────────────────────────────────
-/**
- * Create a provider factory function for the `plugin` namespace.
- *
- * @param pluginConfigs - Map of plugin provider ID → config (from crewx.yaml `providers:` section)
- * @returns ProviderFactory to register via registerProviderFactory('plugin', factory)
- */
-export function createPluginProviderFactory(pluginConfigs) {
-    return (id, _providerStr) => {
-        const config = pluginConfigs.get(id);
-        if (!config) {
-            throw new ProviderError(`Plugin provider "${id}" not found. Available: ${Array.from(pluginConfigs.keys()).join(', ') || '(none)'}`, `plugin/${id}`);
-        }
-        return new PluginProviderRuntime(id, config);
-    };
-}
-// ── Helpers ─────────────────────────────────────────────────────────────────
-/**
- * Build the final args array for a CLI invocation:
- * 1. Replace `{model}` placeholders in each arg.
- * 2. If promptInArgs is true, append the prompt as a positional argument.
- */
-function resolveArgs(templateArgs, model, prompt, promptInArgs) {
-    const args = templateArgs.map(arg => arg.replace(/\{model\}/g, model));
-    if (promptInArgs) {
-        args.push(prompt);
-    }
-    return args;
-}
-// ── Validation ───────────────────────────────────────────────────────────────
-function validateCliCommand(cliCommand) {
-    if (!cliCommand || typeof cliCommand !== 'string') {
-        throw new Error('Plugin provider requires a cli_command');
-    }
-}
-function validateCliArgs(args) {
-    if (!Array.isArray(args)) {
-        throw new Error('CLI arguments must be an array');
-    }
-    for (const arg of args) {
-        if (typeof arg !== 'string') {
-            throw new Error('Each CLI argument must be a string');
-        }
-    }
-}
-function validateErrorPatterns(patterns) {
-    for (const { pattern } of patterns) {
-        if (typeof pattern !== 'string') {
-            throw new Error('Error pattern must be a string');
-        }
-    }
-}
-function validateEnv(env) {
-    for (const [key, value] of Object.entries(env)) {
-        if (typeof key !== 'string' || typeof value !== 'string') {
-            throw new Error('env entries must be string key/value pairs');
-        }
-    }
-}
-//# sourceMappingURL=plugin-provider.js.map

package/dist/esm/plugin/types.js

@@ -1,8 +0,0 @@
-/**
- * Plugin Provider Types
- *
- * Configuration for `type: plugin` providers in crewx.yaml.
- * Plugin providers wrap arbitrary CLI tools as CrewX agents.
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/esm/plugin.js

@@ -1,25 +0,0 @@
-/**
- * CrewxPlugin — base class for SDK plugins.
- *
- * Plugins subscribe to Crewx events in attach() and clean up in detach().
- * Register via Crewx.use(plugin).
- *
- * @example
- * class MyPlugin extends CrewxPlugin {
- *   readonly name = 'my-plugin';
- *   attach(crewx: Crewx) {
- *     crewx.on('task:start', (e) => console.log(e.traceId));
- *   }
- * }
- * await crewx.use(new MyPlugin());
- */
-export class CrewxPlugin {
-    /**
-     * Called on Crewx.close() in LIFO order.
-     * Remove event listeners and release resources here.
-     * Default: no-op.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    detach(_crewx) { }
-}
-//# sourceMappingURL=plugin.js.map

package/dist/esm/provider/bridge.browser.js

@@ -1,43 +0,0 @@
-/**
- * Browser-safe provider bridge.
- * Registry pattern only — no child_process / CLI spawn.
- */
-export class ProviderError extends Error {
-    providerStr;
-    constructor(message, providerStr) {
-        super(message);
-        this.providerStr = providerStr;
-        this.name = 'ProviderError';
-    }
-}
-// ── Provider factory registry ───────────────────────────────────────────────
-const _providerFactories = new Map();
-/**
- * Register a provider factory for a given namespace.
- *
- * @example
- * registerProviderFactory('api', (id, providerStr) => ({
- *   async query(message, options) { ... },
- *   async execute(message, options) { ... },
- * }));
- */
-export function registerProviderFactory(namespace, factory) {
-    _providerFactories.set(namespace, factory);
-}
-/**
- * Create a provider runtime for the given provider string.
- * Browser version — only supports registered factories (no CLI fallback).
- */
-export function createProvider(providerStr) {
-    const parts = providerStr.split('/');
-    if (parts.length !== 2) {
-        throw new ProviderError(`Invalid provider format: "${providerStr}". Expected namespace/id (e.g., api/webllm)`, providerStr);
-    }
-    const [namespace, id] = parts;
-    const factory = _providerFactories.get(namespace);
-    if (factory) {
-        return factory(id, providerStr);
-    }
-    throw new ProviderError(`Unsupported provider namespace: "${namespace}". Register a factory with registerProviderFactory('${namespace}', factory).`, providerStr);
-}
-//# sourceMappingURL=bridge.browser.js.map