@townco/ui 0.1.14 → 0.1.16

package/dist/core/hooks/index.d.ts

@@ -5,3 +5,4 @@ export * from "./use-chat-input.js";
 export * from "./use-chat-messages.js";
 export * from "./use-chat-session.js";
 export * from "./use-media-query.js";
+export * from "./use-tool-calls.js";

package/dist/core/hooks/index.js

@@ -5,3 +5,4 @@ export * from "./use-chat-input.js";
 export * from "./use-chat-messages.js";
 export * from "./use-chat-session.js";
 export * from "./use-media-query.js";
+export * from "./use-tool-calls.js";

package/dist/core/hooks/use-chat-messages.d.ts

@@ -3,15 +3,54 @@ import type { AcpClient } from "../../sdk/client/index.js";
  * Hook for managing chat messages
  */
 export declare function useChatMessages(client: AcpClient | null): {
-	messages: {
-		id: string;
-		role: "user" | "assistant" | "system";
-		content: string;
-		timestamp: string;
-		isStreaming: boolean;
-		streamingStartTime?: number | undefined;
-		metadata?: Record<string, unknown> | undefined;
-	}[];
-	isStreaming: boolean;
-	sendMessage: (content: string) => Promise<void>;
+    messages: {
+        id: string;
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp: string;
+        isStreaming: boolean;
+        streamingStartTime?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        toolCalls?: {
+            id: string;
+            title: string;
+            kind: "read" | "edit" | "delete" | "move" | "search" | "execute" | "think" | "fetch" | "switch_mode" | "other";
+            status: "pending" | "in_progress" | "completed" | "failed";
+            locations?: {
+                path: string;
+                line?: number | null | undefined;
+            }[] | undefined;
+            rawInput?: Record<string, unknown> | undefined;
+            rawOutput?: Record<string, unknown> | undefined;
+            content?: ({
+                type: "content";
+                content: {
+                    type: "text";
+                    text: string;
+                };
+            } | {
+                type: "text";
+                text: string;
+            } | {
+                type: "diff";
+                path: string;
+                oldText: string;
+                newText: string;
+                line?: number | null | undefined;
+            } | {
+                type: "terminal";
+                terminalId: string;
+            })[] | undefined;
+            error?: string | undefined;
+            startedAt?: number | undefined;
+            completedAt?: number | undefined;
+            tokenUsage?: {
+                inputTokens?: number | undefined;
+                outputTokens?: number | undefined;
+                totalTokens?: number | undefined;
+            } | undefined;
+        }[] | undefined;
+    }[];
+    isStreaming: boolean;
+    sendMessage: (content: string) => Promise<void>;
 };

package/dist/core/hooks/use-chat-session.d.ts

@@ -3,9 +3,9 @@ import type { AcpClient } from "../../sdk/client/index.js";
  * Hook for managing chat session lifecycle
  */
 export declare function useChatSession(client: AcpClient | null): {
-	connectionStatus: "error" | "connecting" | "connected" | "disconnected";
-	sessionId: string | null;
-	connect: () => Promise<void>;
-	startSession: () => Promise<void>;
-	disconnect: () => Promise<void>;
+    connectionStatus: "connecting" | "connected" | "error" | "disconnected";
+    sessionId: string | null;
+    connect: () => Promise<void>;
+    startSession: () => Promise<void>;
+    disconnect: () => Promise<void>;
 };

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

@@ -0,0 +1,52 @@
+import type { AcpClient } from "../../sdk/client/acp-client.js";
+import type { ToolCall } from "../schemas/tool-call.js";
+/**
+ * Hook to track and manage tool calls from ACP sessions
+ *
+ * Subscribes to session updates and tracks tool call lifecycle:
+ * - Receives initial tool_call notifications
+ * - Merges incremental tool_call_update notifications
+ * - Associates tool calls with sessions
+ */
+export declare function useToolCalls(client: AcpClient | null): {
+    toolCalls: Record<string, {
+        id: string;
+        title: string;
+        kind: "read" | "edit" | "delete" | "move" | "search" | "execute" | "think" | "fetch" | "switch_mode" | "other";
+        status: "pending" | "in_progress" | "completed" | "failed";
+        locations?: {
+            path: string;
+            line?: number | null | undefined;
+        }[] | undefined;
+        rawInput?: Record<string, unknown> | undefined;
+        rawOutput?: Record<string, unknown> | undefined;
+        content?: ({
+            type: "content";
+            content: {
+                type: "text";
+                text: string;
+            };
+        } | {
+            type: "text";
+            text: string;
+        } | {
+            type: "diff";
+            path: string;
+            oldText: string;
+            newText: string;
+            line?: number | null | undefined;
+        } | {
+            type: "terminal";
+            terminalId: string;
+        })[] | undefined;
+        error?: string | undefined;
+        startedAt?: number | undefined;
+        completedAt?: number | undefined;
+        tokenUsage?: {
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
+        } | undefined;
+    }[]>;
+    getToolCallsForSession: (sessionId: string) => ToolCall[];
+};

package/dist/core/hooks/use-tool-calls.js

@@ -0,0 +1,61 @@
+import { useEffect } from "react";
+import { useChatStore } from "../store/chat-store.js";
+/**
+ * Hook to track and manage tool calls from ACP sessions
+ *
+ * Subscribes to session updates and tracks tool call lifecycle:
+ * - Receives initial tool_call notifications
+ * - Merges incremental tool_call_update notifications
+ * - Associates tool calls with sessions
+ */
+export function useToolCalls(client) {
+    const toolCalls = useChatStore((state) => state.toolCalls);
+    const addToolCall = useChatStore((state) => state.addToolCall);
+    const updateToolCall = useChatStore((state) => state.updateToolCall);
+    const addToolCallToCurrentMessage = useChatStore((state) => state.addToolCallToCurrentMessage);
+    const updateToolCallInCurrentMessage = useChatStore((state) => state.updateToolCallInCurrentMessage);
+    useEffect(() => {
+        if (!client)
+            return;
+        // Subscribe to session updates for tool calls
+        const unsubscribe = client.onSessionUpdate((update) => {
+            if (update.type === "tool_call") {
+                // Initial tool call notification
+                // Add to session-level tool calls (for sidebar)
+                addToolCall(update.sessionId, update.toolCall);
+                // Also add to current assistant message (for inline display)
+                addToolCallToCurrentMessage(update.toolCall);
+            }
+            else if (update.type === "tool_call_update") {
+                // Tool call update notification
+                // Update session-level tool calls (for sidebar)
+                updateToolCall(update.sessionId, update.toolCallUpdate);
+                // Also update in current assistant message (for inline display)
+                updateToolCallInCurrentMessage(update.toolCallUpdate);
+            }
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [
+        client,
+        addToolCall,
+        updateToolCall,
+        addToolCallToCurrentMessage,
+        updateToolCallInCurrentMessage,
+    ]);
+    return {
+        toolCalls,
+        getToolCallsForSession: (sessionId) => {
+            // First try the exact session ID
+            const exactMatch = toolCalls[sessionId];
+            if (exactMatch && exactMatch.length > 0) {
+                return exactMatch;
+            }
+            // If no exact match, return all tool calls from all sessions
+            // This handles the case where the UI session ID doesn't match the ACP session ID
+            const allToolCalls = Object.values(toolCalls).flat();
+            return allToolCalls;
+        },
+    };
+}

package/dist/core/index.d.ts

@@ -5,5 +5,6 @@
  * Contains business logic, state management, and hooks
  */
 export * from "./hooks/index.js";
+export * from "./lib/logger.js";
 export * from "./schemas/index.js";
 export * from "./store/chat-store.js";

package/dist/core/index.js

@@ -5,5 +5,6 @@
  * Contains business logic, state management, and hooks
  */
 export * from "./hooks/index.js";
+export * from "./lib/logger.js";
 export * from "./schemas/index.js";
 export * from "./store/chat-store.js";

package/dist/core/lib/logger.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Browser-compatible logger
+ * Outputs structured JSON logs to console with color-coding
+ */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+export declare class Logger {
+    private service;
+    private minLevel;
+    constructor(service: string, minLevel?: LogLevel);
+    private shouldLog;
+    private log;
+    trace(message: string, metadata?: Record<string, unknown>): void;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    fatal(message: string, metadata?: Record<string, unknown>): void;
+}
+/**
+ * Create a logger instance for a service
+ * @param service - Service name (e.g., "gui", "http-agent", "tui")
+ * @param minLevel - Minimum log level to display (default: "debug")
+ */
+export declare function createLogger(service: string, minLevel?: LogLevel): Logger;

package/dist/core/lib/logger.js

@@ -0,0 +1,108 @@
+/**
+ * Browser-compatible logger
+ * Outputs structured JSON logs to console with color-coding
+ */
+const LOG_LEVELS = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+    fatal: 5,
+};
+const _LOG_COLORS = {
+    trace: "#6B7280", // gray
+    debug: "#3B82F6", // blue
+    info: "#10B981", // green
+    warn: "#F59E0B", // orange
+    error: "#EF4444", // red
+    fatal: "#DC2626", // dark red
+};
+const LOG_STYLES = {
+    trace: "color: #6B7280",
+    debug: "color: #3B82F6; font-weight: bold",
+    info: "color: #10B981; font-weight: bold",
+    warn: "color: #F59E0B; font-weight: bold",
+    error: "color: #EF4444; font-weight: bold",
+    fatal: "color: #DC2626; font-weight: bold; background: #FEE2E2",
+};
+export class Logger {
+    service;
+    minLevel;
+    constructor(service, minLevel = "debug") {
+        this.service = service;
+        this.minLevel = minLevel;
+        // In production, suppress trace and debug logs
+        if (typeof process !== "undefined" &&
+            process.env?.NODE_ENV === "production") {
+            this.minLevel = "info";
+        }
+    }
+    shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.minLevel];
+    }
+    log(level, message, metadata) {
+        if (!this.shouldLog(level)) {
+            return;
+        }
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            service: this.service,
+            message,
+            ...(metadata && { metadata }),
+        };
+        // Console output with color-coding
+        const style = LOG_STYLES[level];
+        const levelUpper = level.toUpperCase().padEnd(5);
+        if (typeof console !== "undefined") {
+            // Format: [timestamp] [SERVICE] [LEVEL] message
+            const prefix = `%c[${entry.timestamp}] [${this.service}] [${levelUpper}]`;
+            const msg = metadata ? `${message} %o` : message;
+            switch (level) {
+                case "trace":
+                case "debug":
+                case "info":
+                    console.log(prefix, style, msg, ...(metadata ? [metadata] : []));
+                    break;
+                case "warn":
+                    console.warn(prefix, style, msg, ...(metadata ? [metadata] : []));
+                    break;
+                case "error":
+                case "fatal":
+                    console.error(prefix, style, msg, ...(metadata ? [metadata] : []));
+                    break;
+            }
+        }
+        // Also log the structured JSON for debugging
+        if (level === "fatal" || level === "error") {
+            console.debug("Structured log:", JSON.stringify(entry));
+        }
+    }
+    trace(message, metadata) {
+        this.log("trace", message, metadata);
+    }
+    debug(message, metadata) {
+        this.log("debug", message, metadata);
+    }
+    info(message, metadata) {
+        this.log("info", message, metadata);
+    }
+    warn(message, metadata) {
+        this.log("warn", message, metadata);
+    }
+    error(message, metadata) {
+        this.log("error", message, metadata);
+    }
+    fatal(message, metadata) {
+        this.log("fatal", message, metadata);
+    }
+}
+/**
+ * Create a logger instance for a service
+ * @param service - Service name (e.g., "gui", "http-agent", "tui")
+ * @param minLevel - Minimum log level to display (default: "debug")
+ */
+export function createLogger(service, minLevel = "debug") {
+    return new Logger(service, minLevel);
+}

package/dist/core/schemas/chat.d.ts

@@ -5,101 +5,184 @@ import { z } from "zod";
 /**
  * Display message schema (UI representation of messages)
  */
-export declare const DisplayMessage: z.ZodObject<
-	{
-		id: z.ZodString;
-		role: z.ZodEnum<{
-			user: "user";
-			assistant: "assistant";
-			system: "system";
-		}>;
-		content: z.ZodString;
-		timestamp: z.ZodISODateTime;
-		isStreaming: z.ZodDefault<z.ZodBoolean>;
-		streamingStartTime: z.ZodOptional<z.ZodNumber>;
-		metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-	},
-	z.core.$strip
->;
+export declare const DisplayMessage: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+        system: "system";
+    }>;
+    content: z.ZodString;
+    timestamp: z.ZodISODateTime;
+    isStreaming: z.ZodDefault<z.ZodBoolean>;
+    streamingStartTime: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        kind: z.ZodEnum<{
+            read: "read";
+            edit: "edit";
+            delete: "delete";
+            move: "move";
+            search: "search";
+            execute: "execute";
+            think: "think";
+            fetch: "fetch";
+            switch_mode: "switch_mode";
+            other: "other";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+        rawInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        rawOutput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        content: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"content">;
+            content: z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"diff">;
+            path: z.ZodString;
+            oldText: z.ZodString;
+            newText: z.ZodString;
+            line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"terminal">;
+            terminalId: z.ZodString;
+        }, z.core.$strip>], "type">>>;
+        error: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+        tokenUsage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodOptional<z.ZodNumber>;
+            outputTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type DisplayMessage = z.infer<typeof DisplayMessage>;
 /**
  * Input state schema
  */
-export declare const InputState: z.ZodObject<
-	{
-		value: z.ZodString;
-		isSubmitting: z.ZodBoolean;
-		attachedFiles: z.ZodArray<
-			z.ZodObject<
-				{
-					name: z.ZodString;
-					path: z.ZodString;
-					size: z.ZodNumber;
-					mimeType: z.ZodString;
-				},
-				z.core.$strip
-			>
-		>;
-	},
-	z.core.$strip
->;
+export declare const InputState: z.ZodObject<{
+    value: z.ZodString;
+    isSubmitting: z.ZodBoolean;
+    attachedFiles: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        size: z.ZodNumber;
+        mimeType: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type InputState = z.infer<typeof InputState>;
 /**
  * Chat session UI state
  */
-export declare const ChatSessionState: z.ZodObject<
-	{
-		sessionId: z.ZodNullable<z.ZodString>;
-		isConnected: z.ZodBoolean;
-		isStreaming: z.ZodBoolean;
-		messages: z.ZodArray<
-			z.ZodObject<
-				{
-					id: z.ZodString;
-					role: z.ZodEnum<{
-						user: "user";
-						assistant: "assistant";
-						system: "system";
-					}>;
-					content: z.ZodString;
-					timestamp: z.ZodISODateTime;
-					isStreaming: z.ZodDefault<z.ZodBoolean>;
-					streamingStartTime: z.ZodOptional<z.ZodNumber>;
-					metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-				},
-				z.core.$strip
-			>
-		>;
-		input: z.ZodObject<
-			{
-				value: z.ZodString;
-				isSubmitting: z.ZodBoolean;
-				attachedFiles: z.ZodArray<
-					z.ZodObject<
-						{
-							name: z.ZodString;
-							path: z.ZodString;
-							size: z.ZodNumber;
-							mimeType: z.ZodString;
-						},
-						z.core.$strip
-					>
-				>;
-			},
-			z.core.$strip
-		>;
-		error: z.ZodNullable<z.ZodString>;
-	},
-	z.core.$strip
->;
+export declare const ChatSessionState: z.ZodObject<{
+    sessionId: z.ZodNullable<z.ZodString>;
+    isConnected: z.ZodBoolean;
+    isStreaming: z.ZodBoolean;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+            system: "system";
+        }>;
+        content: z.ZodString;
+        timestamp: z.ZodISODateTime;
+        isStreaming: z.ZodDefault<z.ZodBoolean>;
+        streamingStartTime: z.ZodOptional<z.ZodNumber>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            kind: z.ZodEnum<{
+                read: "read";
+                edit: "edit";
+                delete: "delete";
+                move: "move";
+                search: "search";
+                execute: "execute";
+                think: "think";
+                fetch: "fetch";
+                switch_mode: "switch_mode";
+                other: "other";
+            }>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                in_progress: "in_progress";
+                completed: "completed";
+                failed: "failed";
+            }>;
+            locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>>;
+            rawInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            rawOutput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            content: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"content">;
+                content: z.ZodObject<{
+                    type: z.ZodLiteral<"text">;
+                    text: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"diff">;
+                path: z.ZodString;
+                oldText: z.ZodString;
+                newText: z.ZodString;
+                line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"terminal">;
+                terminalId: z.ZodString;
+            }, z.core.$strip>], "type">>>;
+            error: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodOptional<z.ZodNumber>;
+            completedAt: z.ZodOptional<z.ZodNumber>;
+            tokenUsage: z.ZodOptional<z.ZodObject<{
+                inputTokens: z.ZodOptional<z.ZodNumber>;
+                outputTokens: z.ZodOptional<z.ZodNumber>;
+                totalTokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    input: z.ZodObject<{
+        value: z.ZodString;
+        isSubmitting: z.ZodBoolean;
+        attachedFiles: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+            size: z.ZodNumber;
+            mimeType: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
 export type ChatSessionState = z.infer<typeof ChatSessionState>;
 /**
  * Connection status
  */
 export declare const ConnectionStatus: z.ZodEnum<{
-	error: "error";
-	disconnected: "disconnected";
-	connecting: "connecting";
-	connected: "connected";
+    error: "error";
+    connecting: "connecting";
+    connected: "connected";
+    disconnected: "disconnected";
 }>;
 export type ConnectionStatus = z.infer<typeof ConnectionStatus>;