@artyfacts/claude 1.0.0 → 1.1.1

package/dist/index.d.mts

@@ -1,312 +1,241 @@
-import { EventEmitter } from 'events';
-import { ChildProcess } from 'child_process';
-
 /**
- * Artyfacts API Client (Simplified)
+ * Device authentication flow for Artyfacts Claude adapter
  *
- * Handles communication with the Artyfacts API for task management.
+ * Implements device auth flow:
+ * 1. Request device code from Artyfacts
+ * 2. Display code for user to enter on website
+ * 3. Poll for completion
+ * 4. Store credentials locally
  */
-interface ArtyfactsConfig {
+interface Credentials {
     apiKey: string;
-    baseUrl?: string;
-    agentId?: string;
-}
-interface Task {
-    id: string;
-    sectionId: string;
-    heading: string;
-    content: string;
-    artifactId: string;
-    artifactTitle: string;
-    artifactUrl: string;
-    priority: 1 | 2 | 3;
-    dependsOn: string[];
-    createdAt: string;
+    agentId: string;
+    agentName?: string;
+    expiresAt?: string;
 }
-interface ClaimResult {
-    success: boolean;
-    task: Task & {
-        claimedAt: string;
-        claimedBy: string;
-    };
-}
-interface CompleteResult {
-    success: boolean;
-    unblockedTasks: string[];
+interface DeviceAuthResponse {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    expiresIn: number;
+    interval: number;
 }
-declare class ArtyfactsClient {
-    private config;
-    constructor(config: ArtyfactsConfig);
-    private fetch;
-    /**
-     * Get claimable tasks from the queue
-     */
-    getTaskQueue(options?: {
-        limit?: number;
-    }): Promise<Task[]>;
-    /**
-     * Claim a task
-     */
-    claimTask(taskId: string): Promise<ClaimResult>;
-    /**
-     * Complete a task
-     */
-    completeTask(taskId: string, options?: {
-        outputUrl?: string;
-        summary?: string;
-    }): Promise<CompleteResult>;
-    /**
-     * Report task as blocked
-     */
-    blockTask(taskId: string, reason: string): Promise<void>;
-    /**
-     * Get current user/org info
-     */
-    getMe(): Promise<{
-        id: string;
-        name: string;
-        orgId: string;
-    }>;
+interface TokenResponse {
+    apiKey: string;
+    agentId: string;
+    agentName?: string;
+    expiresAt?: string;
 }
+/**
+ * Load stored credentials from disk
+ */
+declare function loadCredentials(): Credentials | null;
+/**
+ * Save credentials to disk
+ */
+declare function saveCredentials(credentials: Credentials): void;
+/**
+ * Clear stored credentials
+ */
+declare function clearCredentials(): void;
+/**
+ * Run the device authentication flow
+ */
+declare function runDeviceAuth(baseUrl?: string): Promise<Credentials>;
+/**
+ * Prompt user for manual API key entry
+ */
+declare function promptForApiKey(): Promise<Credentials>;
+/**
+ * Get credentials, running auth flow if needed
+ */
+declare function getCredentials(options?: {
+    baseUrl?: string;
+    forceAuth?: boolean;
+}): Promise<Credentials>;
 
 /**
- * Claude Code Runner
+ * Claude Code executor for Artyfacts tasks
  *
- * Spawns and manages Claude Code CLI processes for task execution.
+ * Executes tasks by shelling out to the Claude Code CLI (claude).
+ * This uses the user's existing Claude Code authentication - no separate API key needed.
  */
-
-interface ClaudeRunnerConfig {
-    /** Path to claude CLI (default: 'claude') */
-    claudePath?: string;
-    /** Model to use (default: 'sonnet') */
-    model?: string;
-    /** Working directory for Claude */
-    cwd?: string;
-    /** Timeout in ms (default: 5 minutes) */
-    timeoutMs?: number;
-}
-interface TaskResult {
+interface TaskContext {
+    /** Task ID (section ID) */
+    taskId: string;
+    /** Task heading/title */
+    heading: string;
+    /** Task content/description */
+    content: string;
+    /** Parent artifact ID */
+    artifactId: string;
+    /** Parent artifact title */
+    artifactTitle?: string;
+    /** Task priority (1=high, 2=medium, 3=low) */
+    priority?: number;
+    /** Additional context */
+    context?: Record<string, unknown>;
+}
+interface ExecutionResult {
+    /** Whether execution was successful */
     success: boolean;
+    /** The generated output */
     output: string;
+    /** Summary of what was accomplished */
+    summary: string;
+    /** Any error message if failed */
     error?: string;
-    exitCode: number | null;
-    durationMs: number;
 }
-interface RunningTask {
-    taskId: string;
-    process: ChildProcess;
-    startedAt: Date;
-    promise: Promise<TaskResult>;
+interface ExecutorConfig {
+    /** Path to claude CLI (default: 'claude') */
+    claudePath?: string;
+    /** Timeout in milliseconds (default: 5 minutes) */
+    timeout?: number;
+    /** System prompt prefix */
+    systemPromptPrefix?: string;
 }
-declare class ClaudeRunner extends EventEmitter {
+declare class ClaudeExecutor {
     private config;
-    private runningTasks;
-    constructor(config?: ClaudeRunnerConfig);
+    constructor(config?: ExecutorConfig);
     /**
-     * Check if Claude Code is installed and authenticated
+     * Execute a task using Claude Code CLI
      */
-    checkInstalled(): Promise<{
-        installed: boolean;
-        authenticated: boolean;
-        version?: string;
-        error?: string;
-    }>;
+    execute(task: TaskContext): Promise<ExecutionResult>;
     /**
-     * Run a task with Claude Code
+     * Run Claude Code CLI with the given prompt
      */
-    runTask(taskId: string, prompt: string, options?: {
-        cwd?: string;
-        model?: string;
-        timeoutMs?: number;
-    }): Promise<TaskResult>;
+    private runClaude;
     /**
-     * Run a raw claude command
+     * Build the task prompt
      */
-    private runCommand;
+    private buildTaskPrompt;
     /**
-     * Cancel a running task
+     * Parse the response to extract output and summary
      */
-    cancelTask(taskId: string): boolean;
+    private parseResponse;
     /**
-     * Get count of running tasks
+     * Test that Claude Code CLI is available and working
      */
-    getRunningCount(): number;
+    testConnection(): Promise<boolean>;
     /**
-     * Cancel all running tasks
+     * Check if Claude Code CLI is installed
      */
-    cancelAll(): void;
+    isInstalled(): Promise<boolean>;
 }
+/**
+ * Create a Claude executor
+ */
+declare function createExecutor(config?: ExecutorConfig): ClaudeExecutor;
 
 /**
- * Claude Adapter
+ * SSE Event Listener for Artyfacts task assignments
  *
- * Main orchestration class that:
- * 1. Polls Artyfacts for claimable tasks
- * 2. Spawns Claude Code to execute them
- * 3. Reports results back to Artyfacts
+ * Connects to the Artyfacts SSE stream and listens for task_assigned events.
+ * Uses EventSource for automatic reconnection handling.
  */
-
-interface AdapterConfig {
+interface TaskAssignedEvent {
+    type: 'task_assigned';
+    timestamp: string;
+    data: {
+        taskId: string;
+        sectionId: string;
+        heading: string;
+        content: string;
+        artifactId: string;
+        artifactTitle?: string;
+        priority?: number;
+        assignedTo: string;
+        assignedAt: string;
+    };
+}
+interface HeartbeatEvent {
+    type: 'heartbeat';
+    timestamp: string;
+}
+interface ConnectedEvent {
+    type: 'connected';
+    timestamp: string;
+    data: {
+        agentId: string;
+    };
+}
+type ArtyfactsEvent = TaskAssignedEvent | HeartbeatEvent | ConnectedEvent | {
+    type: string;
+    timestamp: string;
+    data?: Record<string, unknown>;
+};
+type EventCallback<T extends ArtyfactsEvent = ArtyfactsEvent> = (event: T) => void | Promise<void>;
+interface ListenerConfig {
     /** Artyfacts API key */
     apiKey: string;
-    /** Artyfacts base URL */
+    /** Agent ID to listen for */
+    agentId: string;
+    /** Base URL for Artyfacts API */
     baseUrl?: string;
-    /** Agent ID for attribution */
-    agentId?: string;
-    /** Poll interval in ms (default: 30s) */
-    pollIntervalMs?: number;
-    /** Max concurrent tasks (default: 1) */
-    maxConcurrent?: number;
-    /** Claude model to use (default: 'sonnet') */
-    model?: string;
-    /** Working directory for Claude */
-    cwd?: string;
-}
-interface AdapterEvents {
-    'started': () => void;
-    'stopped': () => void;
-    'poll': (tasks: Task[]) => void;
-    'task:claimed': (task: Task) => void;
-    'task:running': (task: Task) => void;
-    'task:completed': (task: Task, result: TaskResult) => void;
-    'task:failed': (task: Task, error: string) => void;
-    'error': (error: Error) => void;
+    /** Callback for state changes */
+    onStateChange?: (state: ConnectionState) => void;
+    /** Callback for errors */
+    onError?: (error: Error) => void;
 }
-declare class ClaudeAdapter extends EventEmitter {
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+declare class ArtyfactsListener {
     private config;
-    private client;
-    private runner;
-    private running;
-    private pollTimer;
-    private activeTasks;
-    constructor(config: AdapterConfig);
+    private eventSource;
+    private callbacks;
+    private allCallbacks;
+    private state;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    constructor(config: ListenerConfig);
     /**
-     * Check if Claude Code is ready
+     * Get current connection state
      */
-    checkReady(): Promise<{
-        ready: boolean;
-        error?: string;
-    }>;
+    get connectionState(): ConnectionState;
     /**
-     * Start the adapter
+     * Check if connected
      */
-    start(): Promise<void>;
+    get isConnected(): boolean;
     /**
-     * Stop the adapter
+     * Subscribe to all events
      */
-    stop(): Promise<void>;
+    subscribe(callback: EventCallback): () => void;
     /**
-     * Poll for and execute tasks
+     * Subscribe to a specific event type
      */
-    private poll;
+    on<T extends ArtyfactsEvent>(type: string, callback: EventCallback<T>): () => void;
     /**
-     * Execute a single task
+     * Connect to the SSE stream
      */
-    private executeTask;
+    connect(): void;
     /**
-     * Build a prompt for Claude from the task
+     * Disconnect from the SSE stream
      */
-    private buildPrompt;
+    disconnect(): void;
     /**
-     * Extract a summary from Claude's output
+     * Reconnect to the SSE stream
      */
-    private extractSummary;
+    reconnect(): void;
     /**
-     * Check if running
+     * Handle incoming SSE message
      */
-    isRunning(): boolean;
+    private handleMessage;
     /**
-     * Get stats
+     * Safely call a callback, handling async and errors
      */
-    getStats(): {
-        running: boolean;
-        activeTasks: number;
-        maxConcurrent: number;
-    };
-}
-
-/**
- * Device Authorization Flow
- *
- * Handles browser-based authentication for the CLI.
- * No API keys to copy — just run the CLI and click authorize.
- */
-interface DeviceCodeResponse {
-    deviceCode: string;
-    userCode: string;
-    verificationUri: string;
-    expiresIn: number;
-    interval: number;
-}
-interface TokenResponse {
-    accessToken: string;
-    refreshToken?: string;
-    expiresAt?: number;
-    user: {
-        id: string;
-        email: string;
-        name?: string;
-        orgId: string;
-    };
-}
-interface StoredCredentials {
-    accessToken: string;
-    refreshToken?: string;
-    expiresAt?: number;
-    user: {
-        id: string;
-        email: string;
-        name?: string;
-        orgId: string;
-    };
-    savedAt: string;
-}
-declare class DeviceAuth {
-    private baseUrl;
-    private credentialsPath;
-    constructor(options?: {
-        baseUrl?: string;
-    });
-    /**
-     * Check if we have stored credentials
-     */
-    hasCredentials(): boolean;
+    private safeCallCallback;
     /**
-     * Get stored credentials
+     * Handle SSE error
      */
-    getCredentials(): StoredCredentials | null;
+    private handleError;
     /**
-     * Get access token (for API calls)
+     * Update connection state
      */
-    getAccessToken(): string | null;
-    /**
-     * Clear stored credentials (logout)
-     */
-    logout(): void;
-    /**
-     * Start device authorization flow
-     */
-    startDeviceFlow(): Promise<DeviceCodeResponse>;
-    /**
-     * Poll for token after user authorizes
-     */
-    pollForToken(deviceCode: string, interval: number, expiresIn: number): Promise<TokenResponse>;
-    /**
-     * Save credentials to disk
-     */
-    saveCredentials(token: TokenResponse): void;
-    /**
-     * Open URL in browser
-     */
-    openBrowser(url: string): void;
-    /**
-     * Full login flow
-     */
-    login(options?: {
-        onDeviceCode?: (response: DeviceCodeResponse) => void;
-        onWaiting?: () => void;
-    }): Promise<TokenResponse>;
-    private sleep;
+    private setState;
 }
+/**
+ * Create an Artyfacts event listener
+ */
+declare function createListener(config: ListenerConfig): ArtyfactsListener;
 
-export { type AdapterConfig, type AdapterEvents, ArtyfactsClient, type ArtyfactsConfig, type ClaimResult, ClaudeAdapter, ClaudeRunner, type ClaudeRunnerConfig, type CompleteResult, DeviceAuth, type DeviceCodeResponse, type RunningTask, type StoredCredentials, type Task, type TaskResult, type TokenResponse };
+export { type ArtyfactsEvent, ArtyfactsListener, ClaudeExecutor, type ConnectedEvent, type ConnectionState, type Credentials, type DeviceAuthResponse, type EventCallback, type ExecutionResult, type ExecutorConfig, type HeartbeatEvent, type ListenerConfig, type TaskAssignedEvent, type TaskContext, type TokenResponse, clearCredentials, createExecutor, createListener, getCredentials, loadCredentials, promptForApiKey, runDeviceAuth, saveCredentials };