profclaw 0.0.1-beta.1

package/dist/hooks/session-end.js

@@ -0,0 +1,153 @@
+/**
+ * Session End (Stop) Hook Handler
+ *
+ * Processes Stop events from Claude Code hooks when a session ends.
+ * Aggregates session data and creates a task record.
+ */
+import { randomUUID } from 'crypto';
+import { SessionEndPayloadSchema } from './schemas.js';
+import { getSessionEvents, clearSessionEvents, getSessionSummary } from './tool-use.js';
+import { aggregateInferences } from '../intelligence/rules.js';
+// Session aggregates storage
+const sessionAggregates = new Map();
+/**
+ * Handle Stop (session end) webhook from Claude Code
+ */
+export async function handleSessionEnd(c) {
+    try {
+        const rawBody = await c.req.text();
+        let payload;
+        try {
+            payload = JSON.parse(rawBody);
+        }
+        catch {
+            try {
+                payload = JSON.parse(JSON.parse(rawBody));
+            }
+            catch {
+                throw new Error('Invalid JSON payload');
+            }
+        }
+        const parsed = SessionEndPayloadSchema.safeParse(payload);
+        if (!parsed.success) {
+            console.error('[Hook] Session end validation failed:', parsed.error.flatten());
+            return {
+                success: false,
+                eventId: '',
+                error: `Validation failed: ${parsed.error.message}`,
+            };
+        }
+        const hookPayload = parsed.data;
+        const sessionId = hookPayload.session_id || 'unknown';
+        // Get all events for this session
+        const events = getSessionEvents(sessionId);
+        const summary = getSessionSummary(sessionId);
+        // Aggregate inferences from all events
+        const inferences = events
+            .map(e => e.inference)
+            .filter((inf) => inf !== undefined);
+        const aggregatedInference = aggregateInferences(inferences);
+        // Create session aggregate
+        const aggregate = {
+            sessionId,
+            startTime: events.length > 0 ? events[0].timestamp : new Date(),
+            endTime: hookPayload.timestamp ? new Date(hookPayload.timestamp) : new Date(),
+            status: mapReasonToStatus(hookPayload.reason),
+            filesModified: summary.filesModified,
+            filesCreated: summary.filesCreated,
+            filesRead: [], // TODO: Track reads separately
+            commandsExecuted: events
+                .filter(e => e.data.tool === 'Bash' && e.data.command)
+                .map(e => e.data.command)
+                .slice(-20), // Keep last 20 commands
+            toolUseCounts: summary.toolUseCounts,
+            inferences,
+            summary: hookPayload.summary || generateSummary(summary, aggregatedInference),
+        };
+        // Store aggregate
+        sessionAggregates.set(sessionId, aggregate);
+        // Log session summary
+        console.log(`[Hook] Session ended: ${sessionId}`);
+        console.log(`[Hook] Files modified: ${aggregate.filesModified.length}`);
+        console.log(`[Hook] Files created: ${aggregate.filesCreated.length}`);
+        console.log(`[Hook] Total tool uses: ${Object.values(summary.toolUseCounts).reduce((a, b) => a + b, 0)}`);
+        // Clear in-memory events (we have the aggregate now)
+        clearSessionEvents(sessionId);
+        return {
+            success: true,
+            eventId: randomUUID(),
+            inference: aggregatedInference.confidence > 0 ? aggregatedInference : undefined,
+        };
+    }
+    catch (error) {
+        console.error('[Hook] Error processing session end:', error);
+        return {
+            success: false,
+            eventId: '',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Map session end reason to status
+ */
+function mapReasonToStatus(reason) {
+    switch (reason) {
+        case 'completed':
+            return 'completed';
+        case 'cancelled':
+            return 'cancelled';
+        case 'error':
+        case 'timeout':
+            return 'error';
+        default:
+            return 'completed';
+    }
+}
+/**
+ * Generate a summary from session data
+ */
+function generateSummary(summary, inference) {
+    const parts = [];
+    if (summary.filesCreated.length > 0) {
+        parts.push(`Created ${summary.filesCreated.length} file(s)`);
+    }
+    if (summary.filesModified.length > 0) {
+        parts.push(`Modified ${summary.filesModified.length} file(s)`);
+    }
+    if (inference.taskType) {
+        parts.push(`Task type: ${inference.taskType}`);
+    }
+    if (inference.component) {
+        parts.push(`Component: ${inference.component}`);
+    }
+    if (inference.linkedIssue) {
+        parts.push(`Related to #${inference.linkedIssue}`);
+    }
+    if (inference.commitMessage) {
+        parts.push(`Commit: "${inference.commitMessage}"`);
+    }
+    return parts.join('. ') || 'Session completed';
+}
+/**
+ * Get a session aggregate by ID
+ */
+export function getSessionAggregate(sessionId) {
+    return sessionAggregates.get(sessionId);
+}
+/**
+ * Get all session aggregates
+ */
+export function getAllSessionAggregates() {
+    return [...sessionAggregates.values()];
+}
+/**
+ * Get recent session aggregates
+ */
+export function getRecentSessions(limit = 50) {
+    const aggregates = [...sessionAggregates.values()];
+    return aggregates
+        .sort((a, b) => (b.endTime?.getTime() || 0) - (a.endTime?.getTime() || 0))
+        .slice(0, limit);
+}
+//# sourceMappingURL=session-end.js.map

package/dist/hooks/tool-use.d.ts

@@ -0,0 +1,41 @@
+/**
+ * PostToolUse Hook Handler
+ *
+ * Processes PostToolUse events from Claude Code hooks.
+ * Zero token cost - uses shell command callback.
+ *
+ * Usage in ~/.claude/settings.json:
+ * {
+ *   "hooks": {
+ *     "PostToolUse": "curl -s -X POST http://localhost:3000/api/hook/tool-use -H 'Content-Type: application/json' -d '$HOOK_PAYLOAD'"
+ *   }
+ * }
+ */
+import type { Context } from 'hono';
+import type { HookEvent, HookProcessingResult } from './types.js';
+/**
+ * Handle PostToolUse webhook from Claude Code
+ */
+export declare function handlePostToolUse(c: Context): Promise<HookProcessingResult>;
+/**
+ * Get all events for a session
+ */
+export declare function getSessionEvents(sessionId: string): HookEvent[];
+/**
+ * Get a specific event by ID
+ */
+export declare function getEvent(eventId: string): HookEvent | undefined;
+/**
+ * Get session summary from events
+ */
+export declare function getSessionSummary(sessionId: string): {
+    eventCount: number;
+    filesModified: string[];
+    filesCreated: string[];
+    toolUseCounts: Record<string, number>;
+};
+/**
+ * Clear events for a session (after session ends)
+ */
+export declare function clearSessionEvents(sessionId: string): void;
+//# sourceMappingURL=tool-use.d.ts.map

package/dist/hooks/tool-use.js

@@ -0,0 +1,201 @@
+/**
+ * PostToolUse Hook Handler
+ *
+ * Processes PostToolUse events from Claude Code hooks.
+ * Zero token cost - uses shell command callback.
+ *
+ * Usage in ~/.claude/settings.json:
+ * {
+ *   "hooks": {
+ *     "PostToolUse": "curl -s -X POST http://localhost:3000/api/hook/tool-use -H 'Content-Type: application/json' -d '$HOOK_PAYLOAD'"
+ *   }
+ * }
+ */
+import { randomUUID } from 'crypto';
+import { PostToolUsePayloadSchema } from './schemas.js';
+import { inferFromToolUse } from '../intelligence/rules.js';
+// In-memory storage for hook events (will be replaced with DB later)
+const hookEvents = new Map();
+const sessionEvents = new Map();
+// Maximum events per session to prevent memory bloat
+const MAX_EVENTS_PER_SESSION = 1000;
+/**
+ * Handle PostToolUse webhook from Claude Code
+ */
+export async function handlePostToolUse(c) {
+    try {
+        const rawBody = await c.req.text();
+        // Handle escaped JSON from shell (curl with $HOOK_PAYLOAD)
+        let payload;
+        try {
+            payload = JSON.parse(rawBody);
+        }
+        catch {
+            // Try unescaping if double-escaped
+            try {
+                payload = JSON.parse(JSON.parse(rawBody));
+            }
+            catch {
+                throw new Error('Invalid JSON payload');
+            }
+        }
+        // Validate payload
+        const parsed = PostToolUsePayloadSchema.safeParse(payload);
+        if (!parsed.success) {
+            console.error('[Hook] Validation failed:', parsed.error.flatten());
+            return {
+                success: false,
+                eventId: '',
+                error: `Validation failed: ${parsed.error.message}`,
+            };
+        }
+        const hookPayload = parsed.data;
+        // Run inference
+        const inference = inferFromToolUse(hookPayload);
+        // Extract event data
+        const eventData = extractEventData(hookPayload);
+        // Create hook event
+        const event = {
+            id: randomUUID(),
+            sessionId: hookPayload.session_id || 'unknown',
+            event: 'PostToolUse',
+            timestamp: hookPayload.timestamp ? new Date(hookPayload.timestamp) : new Date(),
+            workingDirectory: hookPayload.working_directory,
+            data: eventData,
+            inference: inference.confidence > 0 ? inference : undefined,
+        };
+        // Store event
+        storeEvent(event);
+        // Log for debugging
+        console.log(`[Hook] PostToolUse: ${hookPayload.tool} on ${eventData.filePath || 'N/A'}`);
+        if (inference.confidence > 0) {
+            console.log(`[Hook] Inference: ${JSON.stringify(inference)}`);
+        }
+        return {
+            success: true,
+            eventId: event.id,
+            inference: event.inference,
+        };
+    }
+    catch (error) {
+        console.error('[Hook] Error processing PostToolUse:', error);
+        return {
+            success: false,
+            eventId: '',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Extract structured data from hook payload
+ */
+function extractEventData(payload) {
+    const input = payload.input;
+    const output = payload.output;
+    const data = {
+        tool: payload.tool,
+    };
+    // Extract file path
+    if (input.file_path) {
+        data.filePath = String(input.file_path);
+    }
+    else if (input.path) {
+        data.filePath = String(input.path);
+    }
+    // Determine action
+    switch (payload.tool) {
+        case 'Edit':
+            data.action = 'modify';
+            break;
+        case 'Write':
+            data.action = 'create';
+            break;
+        case 'Read':
+            data.action = 'read';
+            break;
+        case 'Bash':
+            data.action = 'execute';
+            data.command = String(input.command || '');
+            break;
+        case 'Delete':
+            data.action = 'delete';
+            break;
+    }
+    // Extract error if present
+    if (output?.error) {
+        data.error = String(output.error);
+    }
+    return data;
+}
+/**
+ * Store event in memory and by session
+ */
+function storeEvent(event) {
+    hookEvents.set(event.id, event);
+    // Add to session events
+    let events = sessionEvents.get(event.sessionId);
+    if (!events) {
+        events = [];
+        sessionEvents.set(event.sessionId, events);
+    }
+    // Enforce max events per session
+    if (events.length >= MAX_EVENTS_PER_SESSION) {
+        events.shift(); // Remove oldest
+    }
+    events.push(event);
+}
+/**
+ * Get all events for a session
+ */
+export function getSessionEvents(sessionId) {
+    return sessionEvents.get(sessionId) || [];
+}
+/**
+ * Get a specific event by ID
+ */
+export function getEvent(eventId) {
+    return hookEvents.get(eventId);
+}
+/**
+ * Get session summary from events
+ */
+export function getSessionSummary(sessionId) {
+    const events = getSessionEvents(sessionId);
+    const filesModified = new Set();
+    const filesCreated = new Set();
+    const toolUseCounts = {};
+    for (const event of events) {
+        // Count tool usage
+        if (event.data.tool) {
+            toolUseCounts[event.data.tool] = (toolUseCounts[event.data.tool] || 0) + 1;
+        }
+        // Track file changes
+        if (event.data.filePath) {
+            if (event.data.action === 'create') {
+                filesCreated.add(event.data.filePath);
+            }
+            else if (event.data.action === 'modify') {
+                filesModified.add(event.data.filePath);
+            }
+        }
+    }
+    return {
+        eventCount: events.length,
+        filesModified: [...filesModified],
+        filesCreated: [...filesCreated],
+        toolUseCounts,
+    };
+}
+/**
+ * Clear events for a session (after session ends)
+ */
+export function clearSessionEvents(sessionId) {
+    const events = sessionEvents.get(sessionId);
+    if (events) {
+        for (const event of events) {
+            hookEvents.delete(event.id);
+        }
+        sessionEvents.delete(sessionId);
+    }
+}
+//# sourceMappingURL=tool-use.js.map

package/dist/hooks/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Hook Types for profClaw
+ *
+ * Types for processing and storing hook events from Claude Code and other agents.
+ */
+export type HookEventType = 'PostToolUse' | 'Stop' | 'UserPromptSubmit';
+/**
+ * Processed hook event stored by profClaw
+ */
+export interface HookEvent {
+    id: string;
+    sessionId: string;
+    event: HookEventType;
+    timestamp: Date;
+    workingDirectory?: string;
+    data: HookEventData;
+    inference?: HookInference;
+}
+/**
+ * Data extracted from hook payload
+ */
+export interface HookEventData {
+    tool?: string;
+    filePath?: string;
+    action?: 'create' | 'modify' | 'delete' | 'read' | 'execute';
+    linesChanged?: number;
+    command?: string;
+    error?: string;
+    summary?: string;
+}
+/**
+ * Inferences made about the hook by the rules engine
+ */
+export interface HookInference {
+    taskType?: string;
+    component?: string;
+    linkedIssue?: string;
+    linkedPr?: string;
+    commitMessage?: string;
+    confidence: number;
+}
+/**
+ * Session aggregate from multiple hooks
+ */
+export interface SessionAggregate {
+    sessionId: string;
+    startTime: Date;
+    endTime?: Date;
+    status: 'active' | 'completed' | 'cancelled' | 'error';
+    filesModified: string[];
+    filesCreated: string[];
+    filesRead: string[];
+    commandsExecuted: string[];
+    toolUseCounts: Record<string, number>;
+    inferences: HookInference[];
+    summary?: string;
+}
+/**
+ * Hook processing result
+ */
+export interface HookProcessingResult {
+    success: boolean;
+    eventId: string;
+    inference?: HookInference;
+    error?: string;
+}
+/**
+ * Configuration for hook endpoints
+ */
+export interface HookConfig {
+    enabled: boolean;
+    storeEvents: boolean;
+    inferenceEnabled: boolean;
+    maxEventsPerSession: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/hooks/types.js

@@ -0,0 +1,7 @@
+/**
+ * Hook Types for profClaw
+ *
+ * Types for processing and storing hook events from Claude Code and other agents.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/integrations/cloudflare-tunnel.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Cloudflare Tunnel Integration
+ *
+ * Auto-configure Cloudflare Tunnel (cloudflared) for remote access to profClaw.
+ * Alternative to Tailscale for users who prefer Cloudflare's network.
+ *
+ * Two modes:
+ *   1. Quick tunnel (no account needed) - temporary URL
+ *   2. Named tunnel (requires Cloudflare account) - persistent URL with custom domain
+ *
+ * Requirements:
+ *   - cloudflared CLI installed
+ *   - For named tunnels: Cloudflare account + authenticated cloudflared
+ */
+import { EventEmitter } from 'node:events';
+export interface CloudflareStatus {
+    installed: boolean;
+    authenticated: boolean;
+    version?: string;
+}
+export interface QuickTunnelConfig {
+    port: number;
+    protocol?: 'http' | 'https';
+}
+export interface NamedTunnelConfig {
+    name: string;
+    port: number;
+    protocol?: 'http' | 'https';
+    hostname?: string;
+}
+export interface TunnelResult {
+    success: boolean;
+    url?: string;
+    tunnelId?: string;
+    error?: string;
+}
+declare class CloudflareTunnelService extends EventEmitter {
+    private activeProcess;
+    private activeUrl;
+    constructor();
+    /**
+     * Check if cloudflared is installed and authenticated
+     */
+    getStatus(): Promise<CloudflareStatus>;
+    /**
+     * Start a quick tunnel (no account needed, temporary URL)
+     */
+    startQuickTunnel(config: QuickTunnelConfig): Promise<TunnelResult>;
+    /**
+     * Start a named tunnel (requires Cloudflare account)
+     */
+    startNamedTunnel(config: NamedTunnelConfig): Promise<TunnelResult>;
+    /**
+     * Stop the active tunnel
+     */
+    stop(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get current tunnel URL
+     */
+    getActiveUrl(): string | null;
+    /**
+     * Check if tunnel is running
+     */
+    isRunning(): boolean;
+    /**
+     * Delete a named tunnel
+     */
+    deleteTunnel(name: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+export declare function getCloudflareTunnelService(): CloudflareTunnelService;
+export { CloudflareTunnelService };
+//# sourceMappingURL=cloudflare-tunnel.d.ts.map