profclaw 0.0.1-beta.1

package/dist/adapters/openclaw.js

@@ -0,0 +1,289 @@
+// Regex patterns for artifact extraction
+// Defined at module scope to avoid recompilation
+const COMMIT_PATTERN = /(?:commit|committed(?: as)?|sha)[:\s]+([a-f0-9]{6,40})/gi;
+const PR_PATTERN = /https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/g;
+const FILE_PATTERN = /(?:created|modified|edited|wrote|updated|deleted)[:\s]+(?:file\s+)?[`"]?([a-zA-Z0-9_\-./]+\.[a-zA-Z0-9]+)[`"]?/gi;
+/**
+ * OpenClaw Agent Adapter
+ *
+ * Communicates with OpenClaw gateway via REST API to execute tasks.
+ * OpenClaw is an autonomous AI agent that can code, browse, manage files, etc.
+ *
+ * @see https://docs.openclaw.ai/
+ */
+export class OpenClawAdapter {
+    type = "openclaw";
+    name = "OpenClaw";
+    description = "Open-source autonomous AI agent with 124k+ GitHub stars";
+    capabilities = [
+        "code_generation",
+        "code_review",
+        "bug_fix",
+        "testing",
+        "documentation",
+        "refactoring",
+        "research",
+        "git_operations",
+        "file_operations",
+        "web_browsing",
+        "api_calls",
+    ];
+    baseUrl;
+    token;
+    workingDir;
+    timeout;
+    constructor(config) {
+        const { baseUrl, token, workingDir, timeout } = config.config;
+        this.baseUrl =
+            baseUrl || process.env.OPENCLAW_BASE_URL || "http://localhost:18789";
+        this.token = token || process.env.OPENCLAW_GATEWAY_TOKEN || "";
+        this.workingDir =
+            workingDir || process.env.OPENCLAW_WORKING_DIR || "~/openclaw-workdir";
+        this.timeout = timeout || 300000; // 5 minutes default
+        if (!this.token) {
+            throw new Error("OpenClaw gateway token is required");
+        }
+    }
+    /**
+     * Check if OpenClaw gateway is healthy
+     */
+    async healthCheck() {
+        const startTime = Date.now();
+        try {
+            const response = await fetch(`${this.baseUrl}/api/health`, {
+                method: "GET",
+                headers: this.getHeaders(),
+                signal: AbortSignal.timeout(5000),
+            });
+            const latencyMs = Date.now() - startTime;
+            if (response.ok) {
+                return {
+                    healthy: true,
+                    latencyMs,
+                    message: "OpenClaw gateway is healthy",
+                    lastChecked: new Date(),
+                };
+            }
+            return {
+                healthy: false,
+                latencyMs,
+                message: `Gateway returned ${response.status}: ${response.statusText}`,
+                lastChecked: new Date(),
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                latencyMs: Date.now() - startTime,
+                message: error instanceof Error ? error.message : "Unknown error",
+                lastChecked: new Date(),
+            };
+        }
+    }
+    /**
+     * Execute a task via OpenClaw
+     */
+    async executeTask(task) {
+        const startTime = Date.now();
+        try {
+            // Build the prompt with context
+            const fullPrompt = this.buildPrompt(task);
+            // Send to OpenClaw gateway
+            const response = await fetch(`${this.baseUrl}/api/chat`, {
+                method: "POST",
+                headers: this.getHeaders(),
+                body: JSON.stringify({
+                    message: fullPrompt,
+                    options: {
+                        workingDir: task.repository
+                            ? `${this.workingDir}/${task.repository.split("/").pop()}`
+                            : this.workingDir,
+                        // Request structured output for better parsing
+                        systemPrompt: this.getSystemPrompt(task),
+                    },
+                }),
+                signal: AbortSignal.timeout(this.timeout),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    output: "",
+                    duration: Date.now() - startTime,
+                    error: {
+                        code: `HTTP_${response.status}`,
+                        message: `OpenClaw API error: ${response.status} - ${errorText}`,
+                    },
+                };
+            }
+            const result = (await response.json());
+            // Parse the response and extract artifacts
+            const artifacts = extractArtifacts(result);
+            return {
+                success: true,
+                output: result.message || result.response || "",
+                artifacts,
+                tokensUsed: result.usage
+                    ? {
+                        input: result.usage.prompt_tokens || 0,
+                        output: result.usage.completion_tokens || 0,
+                        total: result.usage.total_tokens || 0,
+                    }
+                    : undefined,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: "",
+                duration: Date.now() - startTime,
+                error: {
+                    code: "EXECUTION_ERROR",
+                    message: error instanceof Error ? error.message : "Unknown error",
+                    stack: error instanceof Error ? error.stack : undefined,
+                },
+            };
+        }
+    }
+    /**
+     * Build the full autonomous prompt for OpenClaw
+     */
+    buildPrompt(task) {
+        const repoName = task.repository?.split("/").pop() || "project";
+        const issueNumber = task.sourceId || "N/A";
+        return `You are an autonomous AI developer. Complete this task independently.
+
+## Task: ${task.title}
+${task.description ? `\n### Description\n${task.description}` : ""}
+
+### Source
+${task.sourceUrl ? `- Issue: ${task.sourceUrl}` : ""}
+${task.repository ? `- Repository: ${task.repository}` : ""}
+${task.labels && task.labels.length > 0 ? `- Labels: ${task.labels.join(", ")}` : ""}
+
+### Instructions
+${task.prompt}
+
+## Workflow (FOLLOW EXACTLY)
+
+1. **Setup**
+   \`\`\`bash
+   cd ~/openclaw-workdir/${repoName}
+   git fetch origin
+   git checkout main && git pull origin main
+   git checkout -b fix/issue-${issueNumber}
+   \`\`\`
+
+2. **Implement** - Make the necessary changes
+
+3. **Verify**
+   \`\`\`bash
+   pnpm install && pnpm build
+   \`\`\`
+   Fix any errors before proceeding.
+
+4. **Commit**
+   \`\`\`bash
+   git add -A
+   git commit -m "feat: <short description>
+
+   ${task.sourceId ? `Closes #${task.sourceId}` : ""}
+
+   Co-Authored-By: profClaw <bot@profclaw.dev>"
+   \`\`\`
+
+5. **Push & PR**
+   \`\`\`bash
+   git push -u origin HEAD
+   gh pr create --title "${task.title}" --body "Closes #${issueNumber}"
+   \`\`\`
+
+## Rules
+- Fix ALL build errors before committing
+- If blocked, explain clearly what's wrong
+- Never leave uncommitted changes
+- Keep commits atomic and focused
+
+## Output Required
+When done, report:
+1. Summary of changes
+2. Files modified
+3. PR URL (required)
+4. Any concerns`;
+    }
+    /**
+     * System prompt for structured task execution
+     */
+    getSystemPrompt(task) {
+        return `You are executing a task from an automated task queue.
+
+Task ID: ${task.id}
+Source: ${task.source}
+Priority: ${task.priority}
+
+Guidelines:
+- Focus on completing the specific task requested
+- Make atomic, well-documented changes
+- Commit with clear messages referencing the task
+- Report any blockers or questions clearly
+- Do not make changes outside the scope of this task`;
+    }
+    /**
+     * Get request headers
+     */
+    getHeaders() {
+        return {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.token}`,
+        };
+    }
+}
+/**
+ * Extract artifacts (commits, PRs, files) from OpenClaw response
+ */
+export function extractArtifacts(result) {
+    const artifacts = [];
+    // Parse the response text for commits
+    COMMIT_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = COMMIT_PATTERN.exec(result.message || "")) !== null) {
+        artifacts.push({
+            type: "commit",
+            sha: match[1],
+        });
+    }
+    // Parse for PR URLs
+    PR_PATTERN.lastIndex = 0;
+    while ((match = PR_PATTERN.exec(result.message || "")) !== null) {
+        artifacts.push({
+            type: "pull_request",
+            url: match[0],
+            metadata: {
+                owner: match[1],
+                repo: match[2],
+                number: parseInt(match[3]),
+            },
+        });
+    }
+    // Parse for file paths (simple heuristic)
+    FILE_PATTERN.lastIndex = 0;
+    while ((match = FILE_PATTERN.exec(result.message || "")) !== null) {
+        artifacts.push({
+            type: "file",
+            path: match[1],
+        });
+    }
+    // Add any artifacts from structured response
+    if (result.artifacts) {
+        artifacts.push(...result.artifacts);
+    }
+    return artifacts;
+}
+/**
+ * Factory function for creating OpenClaw adapters
+ */
+export function createOpenClawAdapter(config) {
+    return new OpenClawAdapter(config);
+}
+//# sourceMappingURL=openclaw.js.map

package/dist/adapters/registry.d.ts

@@ -0,0 +1,56 @@
+import type { AgentAdapter, AgentAdapterFactory, AgentConfig, AgentRegistry } from '../types/agent.js';
+import type { Task } from '../types/task.js';
+/**
+ * Default Agent Registry Implementation
+ *
+ * Manages multiple agent adapters and routes tasks to the appropriate agent.
+ */
+export declare class DefaultAgentRegistry implements AgentRegistry {
+    private factories;
+    private adapters;
+    private configs;
+    private cachedAdapterTypes;
+    constructor();
+    /**
+     * Register a new adapter factory
+     */
+    registerAdapter(type: string, factory: AgentAdapterFactory): void;
+    /**
+     * Create and register an adapter instance from config
+     */
+    createAdapter(config: AgentConfig): AgentAdapter;
+    /**
+     * Get all registered adapter types
+     */
+    getAdapterTypes(): string[];
+    /**
+     * Get adapter by instance ID
+     */
+    getAdapter(id: string): AgentAdapter | undefined;
+    /**
+     * Get all active (enabled) adapters
+     */
+    getActiveAdapters(): AgentAdapter[];
+    /**
+     * Find the best adapter for a task based on:
+     * 1. Explicit assignment (task.assignedAgent)
+     * 2. Label matching
+     * 3. Capability matching
+     * 4. Priority weighting
+     */
+    findAdapterForTask(task: Task): AgentAdapter | undefined;
+    /**
+     * Infer task type from labels and content
+     */
+    private inferTaskType;
+    /**
+     * Get adapter config by ID
+     */
+    getConfig(id: string): AgentConfig | undefined;
+    /**
+     * Update adapter config
+     */
+    updateConfig(id: string, updates: Partial<AgentConfig>): void;
+}
+export declare function getAgentRegistry(): AgentRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/adapters/registry.js

@@ -0,0 +1,163 @@
+import { createOpenClawAdapter } from './openclaw.js';
+import { createClaudeCodeAdapter } from './claude-code.js';
+import { createOllamaAdapter } from './ollama.js';
+/**
+ * Default Agent Registry Implementation
+ *
+ * Manages multiple agent adapters and routes tasks to the appropriate agent.
+ */
+export class DefaultAgentRegistry {
+    factories = new Map();
+    adapters = new Map();
+    configs = new Map();
+    cachedAdapterTypes = null;
+    constructor() {
+        // Register built-in adapters
+        this.registerAdapter('openclaw', createOpenClawAdapter);
+        this.registerAdapter('claude-code', createClaudeCodeAdapter);
+        this.registerAdapter('ollama', createOllamaAdapter);
+    }
+    /**
+     * Register a new adapter factory
+     */
+    registerAdapter(type, factory) {
+        this.factories.set(type, factory);
+        this.cachedAdapterTypes = null;
+    }
+    /**
+     * Create and register an adapter instance from config
+     */
+    createAdapter(config) {
+        const factory = this.factories.get(config.type);
+        if (!factory) {
+            throw new Error(`Unknown adapter type: ${config.type}`);
+        }
+        const adapter = factory(config);
+        this.adapters.set(config.id, adapter);
+        this.configs.set(config.id, config);
+        return adapter;
+    }
+    /**
+     * Get all registered adapter types
+     */
+    getAdapterTypes() {
+        if (this.cachedAdapterTypes) {
+            return this.cachedAdapterTypes;
+        }
+        this.cachedAdapterTypes = Array.from(this.factories.keys());
+        return this.cachedAdapterTypes;
+    }
+    /**
+     * Get adapter by instance ID
+     */
+    getAdapter(id) {
+        return this.adapters.get(id);
+    }
+    /**
+     * Get all active (enabled) adapters
+     */
+    getActiveAdapters() {
+        const active = [];
+        for (const [id, config] of this.configs) {
+            if (config.enabled) {
+                const adapter = this.adapters.get(id);
+                if (adapter) {
+                    active.push(adapter);
+                }
+            }
+        }
+        return active;
+    }
+    /**
+     * Find the best adapter for a task based on:
+     * 1. Explicit assignment (task.assignedAgent)
+     * 2. Label matching
+     * 3. Capability matching
+     * 4. Priority weighting
+     */
+    findAdapterForTask(task) {
+        // If explicitly assigned, use that adapter
+        if (task.assignedAgent) {
+            // Check by ID first
+            const adapter = this.adapters.get(task.assignedAgent);
+            if (adapter)
+                return adapter;
+            // Check by type
+            for (const [id, config] of this.configs) {
+                if (config.type === task.assignedAgent && config.enabled) {
+                    return this.adapters.get(id);
+                }
+            }
+        }
+        // Score each adapter
+        const scores = [];
+        const taskType = this.inferTaskType(task);
+        for (const [id, config] of this.configs) {
+            if (!config.enabled)
+                continue;
+            const adapter = this.adapters.get(id);
+            if (!adapter)
+                continue;
+            let score = config.priority || 1;
+            // Label matching
+            if (config.labels && task.labels.length > 0) {
+                const matchingLabels = task.labels.filter((l) => config.labels.includes(l));
+                score += matchingLabels.length * 10;
+            }
+            // Task type matching
+            if (config.taskTypes && config.taskTypes.length > 0) {
+                if (config.taskTypes.includes(taskType)) {
+                    score += 20;
+                }
+            }
+            scores.push({ adapter, score });
+        }
+        // Sort by score descending and return best match
+        scores.sort((a, b) => b.score - a.score);
+        return scores[0]?.adapter;
+    }
+    /**
+     * Infer task type from labels and content
+     */
+    inferTaskType(task) {
+        const labels = task.labels.map((l) => l.toLowerCase());
+        const content = `${task.title} ${task.description || ''} ${task.prompt}`.toLowerCase();
+        if (labels.includes('bug') || content.includes('fix'))
+            return 'bug_fix';
+        if (labels.includes('feature') || content.includes('implement'))
+            return 'feature';
+        if (labels.includes('test') || content.includes('test'))
+            return 'testing';
+        if (labels.includes('docs') || content.includes('documentation'))
+            return 'docs';
+        if (labels.includes('refactor') || content.includes('refactor'))
+            return 'refactor';
+        if (content.includes('review'))
+            return 'code_review';
+        return 'general';
+    }
+    /**
+     * Get adapter config by ID
+     */
+    getConfig(id) {
+        return this.configs.get(id);
+    }
+    /**
+     * Update adapter config
+     */
+    updateConfig(id, updates) {
+        const config = this.configs.get(id);
+        if (config) {
+            this.configs.set(id, { ...config, ...updates });
+        }
+    }
+}
+// Singleton instance
+let registry = null;
+export function getAgentRegistry() {
+    if (!registry) {
+        registry = new DefaultAgentRegistry();
+    }
+    return registry;
+}
+//# sourceMappingURL=registry.js.map

package/dist/agents/executor.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Agent Executor
+ *
+ * The main orchestrator for the profClaw agentic loop system.
+ * Uses AI SDK's native multi-step execution (stopWhen + onStepFinish)
+ * instead of a manual loop. Tools have execute functions and the SDK
+ * handles message accumulation, tool result feeding, and step chaining.
+ */
+import type { LanguageModel, ModelMessage, ToolSet } from "ai";
+import { EventEmitter } from "node:events";
+import type { AgentState, AgentConfig, AgentEvents } from "./types.js";
+type ExecutorTools = ToolSet;
+export declare class AgentExecutor extends EventEmitter<AgentEvents> {
+    private state;
+    private config;
+    private abortController;
+    private isRunning;
+    constructor(sessionId: string, conversationId: string, goal: string, config?: Partial<AgentConfig>);
+    /**
+     * Run the agent until completion or stop condition.
+     * Uses AI SDK's native multi-step execution — a single generateText call
+     * with stopWhen + onStepFinish replaces the old manual loop.
+     */
+    run(model: LanguageModel, messages: ModelMessage[], tools: ExecutorTools, onToolExecute?: (name: string, args: Record<string, unknown>) => Promise<unknown>, providerHint?: string): Promise<AgentState>;
+    /**
+     * Cancel the running agent.
+     */
+    cancel(): void;
+    /**
+     * Get the current state.
+     */
+    getState(): AgentState;
+    /**
+     * Approve pending tool calls.
+     */
+    approvePendingTools(approved: boolean): void;
+    /**
+     * Build provider-specific options based on agent config.
+     * For Anthropic models with effort set, enables extended thinking.
+     */
+    private buildProviderOptions;
+    /**
+     * Wrap tools with execute functions so the AI SDK can auto-execute them.
+     * This is the key change: instead of us manually processing tool calls
+     * after each step, the SDK calls execute() and feeds results back.
+     */
+    private wrapToolsWithExecute;
+    /**
+     * Check custom stop conditions that can't be expressed via AI SDK's stopWhen.
+     * These include consecutive failures, same tool repeated, budget, timeout, etc.
+     * If triggered, we abort the generateText call.
+     */
+    private checkCustomStopConditions;
+    /**
+     * If the same tool has failed consecutively, inject a system hint
+     * telling the AI to try a different approach.
+     */
+    private injectFailureHint;
+    private extractContext;
+    private finalize;
+    private collectArtifacts;
+    private collectNextSteps;
+    private handleError;
+}
+/**
+ * Create an agent executor with default configuration.
+ */
+export declare function createAgent(sessionId: string, conversationId: string, goal: string, config?: Partial<AgentConfig>): AgentExecutor;
+/**
+ * Create an agent executor for simple tasks with lower limits.
+ */
+export declare function createSimpleAgent(sessionId: string, conversationId: string, goal: string): AgentExecutor;
+/**
+ * Create an agent executor for complex tasks with higher limits.
+ */
+export declare function createComplexAgent(sessionId: string, conversationId: string, goal: string): AgentExecutor;
+export {};
+//# sourceMappingURL=executor.d.ts.map