profclaw 0.0.1-beta.1

package/dist/tools/index.js

@@ -0,0 +1,105 @@
+/**
+ * Unified Tool System
+ *
+ * Single source of truth for all profClaw tools.
+ *
+ * Usage:
+ * ```typescript
+ * import { getAllTools, getMCPTools, getChatTools } from './tools/index.js';
+ *
+ * // Get all tools
+ * const tools = getAllTools();
+ *
+ * // Get MCP schemas (with profclaw__ prefix)
+ * const mcpTools = getMCPTools();
+ *
+ * // Get chat execution tools
+ * const chatTools = getChatTools();
+ *
+ * // Handle MCP tool call
+ * const result = await handleMCPToolCall('profclaw__browser_navigate', { url: '...' });
+ * ```
+ */
+export { createToolCollection } from './types.js';
+// Adapters
+export { toMCPSchema, toMCPResult, createMCPHandler, toChatTool, toChatTools, toAISchema, toAISchemas, filterSafeTools, filterByCategory, getToolNames, findTool, } from './adapters.js';
+// Tool Imports (add new tool categories here)
+import { BROWSER_TOOLS } from '../browser/tools.js';
+import { toMCPSchema, toChatTools, createMCPHandler, filterSafeTools, getToolNames, } from './adapters.js';
+// Tool Registry
+/**
+ * All registered tools (single source of truth)
+ */
+const ALL_TOOLS = [
+    // Browser automation tools
+    ...BROWSER_TOOLS,
+    // TODO: Add more tool categories here as they're migrated:
+    // ...FILESYSTEM_TOOLS,
+    // ...GIT_TOOLS,
+    // ...SYSTEM_TOOLS,
+    // ...WEB_TOOLS,
+];
+// Getters
+/**
+ * Get all registered tools
+ */
+export function getAllTools() {
+    return ALL_TOOLS;
+}
+/**
+ * Get safe tools only (for default chat)
+ */
+export function getSafeTools() {
+    return filterSafeTools(ALL_TOOLS);
+}
+/**
+ * Get all tool names
+ */
+export function getAllToolNames() {
+    return getToolNames(ALL_TOOLS);
+}
+/**
+ * Get safe tool names
+ */
+export function getSafeToolNames() {
+    return getToolNames(filterSafeTools(ALL_TOOLS));
+}
+// MCP Integration
+const MCP_PREFIX = 'profclaw__';
+/**
+ * Get MCP tool schemas (with profclaw__ prefix)
+ */
+export function getMCPTools() {
+    return ALL_TOOLS.map((t) => toMCPSchema(t, MCP_PREFIX));
+}
+/**
+ * Handle MCP tool call
+ */
+export const handleMCPToolCall = createMCPHandler(ALL_TOOLS, MCP_PREFIX);
+/**
+ * Check if a name is an MCP tool
+ */
+export function isMCPTool(name) {
+    if (!name.startsWith(MCP_PREFIX))
+        return false;
+    const toolName = name.slice(MCP_PREFIX.length);
+    return ALL_TOOLS.some((t) => t.name === toolName);
+}
+// Chat Execution Integration
+/**
+ * Get chat execution tools
+ */
+export function getChatTools() {
+    return toChatTools(ALL_TOOLS);
+}
+/**
+ * Get safe chat tools (for default mode)
+ */
+export function getSafeChatTools() {
+    return toChatTools(filterSafeTools(ALL_TOOLS));
+}
+// Category-specific exports (for targeted imports)
+export { BROWSER_TOOLS } from '../browser/tools.js';
+// Re-export browser-specific items for backwards compatibility
+export { BROWSER_TOOL_NAMES, SAFE_BROWSER_TOOL_NAMES, } from '../browser/tools.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Unified Tool Types
+ *
+ * Single source of truth for tool definitions.
+ * All tools (browser, filesystem, git, etc.) use these types.
+ */
+import type { z } from 'zod';
+/**
+ * Tool category determines grouping and default permissions
+ */
+export type ToolCategory = 'browser' | 'filesystem' | 'git' | 'system' | 'web' | 'execution' | 'profclaw' | 'memory' | 'data' | 'custom';
+/**
+ * Security level determines approval requirements
+ */
+export type SecurityLevel = 'safe' | 'moderate' | 'dangerous';
+/**
+ * Universal tool definition - define once, use everywhere
+ */
+export interface ToolDefinition<TParams = unknown, TResult = unknown> {
+    /** Tool name (without any prefix) */
+    name: string;
+    /** Tool category for grouping */
+    category: ToolCategory;
+    /** Human-readable description */
+    description: string;
+    /** Security level: safe=read-only, moderate=writes, dangerous=system changes */
+    securityLevel: SecurityLevel;
+    /** Zod schema for parameters */
+    parameters: z.ZodType<TParams, z.ZodTypeDef, unknown>;
+    /**
+     * Optional availability check. If defined, the tool is only included in the
+     * tool list when `available` is true. Tools that require external dependencies
+     * (API keys, services, binaries) should implement this.
+     */
+    isAvailable?: () => ToolAvailability;
+    /** Execute the tool */
+    execute: (params: TParams) => Promise<ToolResult<TResult>>;
+    /** Example usages for documentation */
+    examples?: ToolExample[];
+    /** Optional rate limiting */
+    rateLimit?: {
+        maxCalls: number;
+        windowMs: number;
+    };
+}
+/**
+ * Tool availability check result
+ */
+export interface ToolAvailability {
+    available: boolean;
+    reason?: string;
+}
+/**
+ * Tool execution result
+ */
+export interface ToolResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    output: string;
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+        retryable?: boolean;
+    };
+}
+/**
+ * Tool example for documentation
+ */
+export interface ToolExample {
+    description: string;
+    params: Record<string, unknown>;
+    expectedOutput?: string;
+}
+/**
+ * Tool collection with metadata
+ */
+export interface ToolCollection {
+    /** Category this collection belongs to */
+    category: ToolCategory;
+    /** All tools in this collection */
+    tools: ToolDefinition[];
+    /** Safe tools (read-only, no approval needed) */
+    safeTools: ToolDefinition[];
+    /** Tool names for quick lookup */
+    toolNames: string[];
+    /** Safe tool names for default chat */
+    safeToolNames: string[];
+}
+/**
+ * Create a tool collection from an array of tools
+ */
+export declare function createToolCollection(category: ToolCategory, tools: ToolDefinition[]): ToolCollection;
+/**
+ * MCP tool schema format
+ */
+export interface MCPToolSchema {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/**
+ * Native AI tool schema (OpenAI/Anthropic format)
+ */
+export interface AIToolSchema {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required?: string[];
+        };
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tools/types.js

@@ -0,0 +1,20 @@
+/**
+ * Unified Tool Types
+ *
+ * Single source of truth for tool definitions.
+ * All tools (browser, filesystem, git, etc.) use these types.
+ */
+/**
+ * Create a tool collection from an array of tools
+ */
+export function createToolCollection(category, tools) {
+    const safeTools = tools.filter((t) => t.securityLevel === 'safe');
+    return {
+        category,
+        tools,
+        safeTools,
+        toolNames: tools.map((t) => t.name),
+        safeToolNames: safeTools.map((t) => t.name),
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/types/agent.d.ts

@@ -0,0 +1,101 @@
+import type { Task, TaskResult } from './task.js';
+/**
+ * Agent Adapter Interface
+ *
+ * This is the core abstraction that allows the task manager to work with
+ * any AI agent: OpenClaw, Claude Code, GitHub Copilot, Devin, etc.
+ *
+ * Each adapter implements this interface to handle the specifics of
+ * communicating with that particular agent.
+ */
+export interface AgentAdapter {
+    /** Unique identifier for this adapter type */
+    readonly type: string;
+    /** Human-readable name */
+    readonly name: string;
+    /** Description of the agent's capabilities */
+    readonly description: string;
+    /** What this agent is best at */
+    readonly capabilities: AgentCapability[];
+    /**
+     * Check if the agent is available and healthy
+     */
+    healthCheck(): Promise<AgentHealth>;
+    /**
+     * Execute a task and return the result
+     * This is the main method that sends work to the AI agent
+     */
+    executeTask(task: Task): Promise<TaskResult>;
+    /**
+     * Cancel a running task (if supported)
+     */
+    cancelTask?(taskId: string): Promise<boolean>;
+    /**
+     * Get the current status of a task (if async execution)
+     */
+    getTaskStatus?(taskId: string): Promise<AgentTaskStatus>;
+    /**
+     * Stream task output in real-time (if supported)
+     */
+    streamTaskOutput?(taskId: string): AsyncGenerator<string, void, unknown>;
+}
+/** What an agent can do */
+export type AgentCapability = 'code_generation' | 'code_review' | 'bug_fix' | 'testing' | 'documentation' | 'refactoring' | 'research' | 'git_operations' | 'file_operations' | 'web_browsing' | 'api_calls' | 'image_generation' | 'data_analysis';
+/** Agent health status */
+export interface AgentHealth {
+    healthy: boolean;
+    latencyMs?: number;
+    message?: string;
+    lastChecked: Date;
+    details?: Record<string, unknown>;
+}
+/** Status of a task being executed by an agent */
+export interface AgentTaskStatus {
+    taskId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    progress?: number;
+    currentStep?: string;
+    startedAt?: Date;
+    estimatedCompletion?: Date;
+}
+/**
+ * Configuration for an agent adapter instance
+ */
+export interface AgentConfig {
+    /** Unique instance ID */
+    id: string;
+    /** Adapter type (e.g., 'openclaw', 'claude-code') */
+    type: string;
+    /** Whether this agent is enabled */
+    enabled: boolean;
+    /** Max concurrent tasks this agent can handle */
+    maxConcurrent: number;
+    /** Priority weight (higher = preferred for matching tasks) */
+    priority: number;
+    /** Task types this agent should handle */
+    taskTypes?: string[];
+    /** Labels that route tasks to this agent */
+    labels?: string[];
+    /** Adapter-specific configuration */
+    config: Record<string, unknown>;
+}
+/**
+ * Agent registry for managing multiple agent adapters
+ */
+export interface AgentRegistry {
+    /** Register a new adapter type */
+    registerAdapter(type: string, factory: AgentAdapterFactory): void;
+    /** Create 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 adapters */
+    getActiveAdapters(): AgentAdapter[];
+    /** Find best adapter for a task */
+    findAdapterForTask(task: Task): AgentAdapter | undefined;
+}
+/** Factory function to create adapter instances */
+export type AgentAdapterFactory = (config: AgentConfig) => AgentAdapter;
+//# sourceMappingURL=agent.d.ts.map

package/dist/types/agent.js

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

package/dist/types/errors.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Structured Error Types for profClaw
+ *
+ * Provides a type-safe error hierarchy for better error handling,
+ * categorization, and retry logic.
+ */
+/**
+ * Error categories for classification and handling
+ */
+export declare enum ErrorCategory {
+    /** Configuration or setup issues */
+    CONFIGURATION = "CONFIGURATION",
+    /** Authentication/authorization failures */
+    AUTHENTICATION = "AUTHENTICATION",
+    /** Network connectivity issues (retryable) */
+    NETWORK = "NETWORK",
+    /** External API errors (rate limits, service unavailable) */
+    EXTERNAL_API = "EXTERNAL_API",
+    /** Data validation errors */
+    VALIDATION = "VALIDATION",
+    /** Resource not found */
+    NOT_FOUND = "NOT_FOUND",
+    /** Operation timeout */
+    TIMEOUT = "TIMEOUT",
+    /** Rate limit exceeded */
+    RATE_LIMIT = "RATE_LIMIT",
+    /** Task execution failures */
+    EXECUTION = "EXECUTION",
+    /** Unknown/unexpected errors */
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Error severity levels
+ */
+export declare enum ErrorSeverity {
+    /** Critical - requires immediate attention */
+    CRITICAL = "CRITICAL",
+    /** High - should be investigated soon */
+    HIGH = "HIGH",
+    /** Medium - can be handled in normal workflow */
+    MEDIUM = "MEDIUM",
+    /** Low - informational, may not need action */
+    LOW = "LOW"
+}
+/**
+ * Base application error with enhanced metadata
+ */
+export declare class AppError extends Error {
+    readonly category: ErrorCategory;
+    readonly severity: ErrorSeverity;
+    readonly retryable: boolean;
+    readonly statusCode?: number;
+    readonly metadata?: Record<string, unknown>;
+    readonly timestamp: Date;
+    readonly correlationId?: string;
+    constructor(message: string, options: {
+        category: ErrorCategory;
+        severity?: ErrorSeverity;
+        retryable?: boolean;
+        statusCode?: number;
+        metadata?: Record<string, unknown>;
+        correlationId?: string;
+        cause?: Error;
+    });
+    /**
+     * Convert error to JSON for logging/transmission
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Configuration error (non-retryable)
+ */
+export declare class ConfigurationError extends AppError {
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Authentication error (non-retryable)
+ */
+export declare class AuthenticationError extends AppError {
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Network error (retryable)
+ */
+export declare class NetworkError extends AppError {
+    constructor(message: string, cause?: Error, metadata?: Record<string, unknown>);
+}
+/**
+ * External API error (conditionally retryable)
+ */
+export declare class ExternalAPIError extends AppError {
+    constructor(message: string, statusCode: number, retryable?: boolean, metadata?: Record<string, unknown>);
+}
+/**
+ * Validation error (non-retryable)
+ */
+export declare class ValidationError extends AppError {
+    constructor(message: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Not found error (non-retryable)
+ */
+export declare class NotFoundError extends AppError {
+    constructor(resource: string, id: string, metadata?: Record<string, unknown>);
+}
+/**
+ * Timeout error (retryable)
+ */
+export declare class TimeoutError extends AppError {
+    constructor(operation: string, timeoutMs: number, metadata?: Record<string, unknown>);
+}
+/**
+ * Rate limit error (retryable with backoff)
+ */
+export declare class RateLimitError extends AppError {
+    readonly retryAfter?: number;
+    constructor(message: string, retryAfter?: number, metadata?: Record<string, unknown>);
+}
+/**
+ * Task execution error
+ */
+export declare class TaskExecutionError extends AppError {
+    constructor(taskId: string, message: string, retryable?: boolean, metadata?: Record<string, unknown>);
+}
+/**
+ * Type guard to check if error is an AppError
+ */
+export declare function isAppError(error: unknown): error is AppError;
+/**
+ * Type guard to check if error is retryable
+ */
+export declare function isRetryableError(error: unknown): boolean;
+/**
+ * Convert unknown error to AppError
+ */
+export declare function toAppError(error: unknown): AppError;
+/**
+ * Retry configuration based on error type
+ */
+export interface RetryConfig {
+    maxAttempts: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    backoffMultiplier: number;
+}
+/**
+ * Get retry configuration for an error
+ */
+export declare function getRetryConfig(error: AppError): RetryConfig | null;
+//# sourceMappingURL=errors.d.ts.map