byterover-cli 0.3.4 → 0.4.0

package/dist/tui/hooks/use-activity-logs.js

@@ -0,0 +1,90 @@
+/**
+ * Activity Logs Hook
+ *
+ * Transforms sessionExecutions into ActivityLog format for display.
+ */
+import { join } from 'node:path';
+import { useMemo } from 'react';
+import { array as zArray, object as zObject, string as zString } from 'zod';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
+import { useConsumer } from '../contexts/index.js';
+const ExecutionInputSchema = zObject({
+    content: zString(),
+});
+const CurateResultSchema = zObject({
+    result: zObject({
+        applied: zArray(zObject({
+            path: zString(),
+            status: zString(),
+            type: zString(),
+        })).optional(),
+    }).optional(),
+});
+/**
+ * Parse execution input to extract content
+ */
+export function parseExecutionContent(input) {
+    try {
+        return ExecutionInputSchema.safeParse(JSON.parse(input))?.data?.content ?? input;
+    }
+    catch {
+        return input;
+    }
+}
+/**
+ * Extract file changes from curate tool calls
+ */
+export function composeChangesFromToolCalls(toolCalls) {
+    const changes = { created: [], updated: [] };
+    const contextTreeDir = join(BRV_DIR, CONTEXT_TREE_DIR);
+    for (const tc of toolCalls) {
+        if (tc.status !== 'completed' || tc.name !== 'curate' || !tc.result) {
+            continue;
+        }
+        const parseResult = CurateResultSchema.safeParse(JSON.parse(tc.result));
+        if (!parseResult.success) {
+            continue;
+        }
+        const result = parseResult.data.result || {};
+        for (const operation of result.applied || []) {
+            if (operation.status !== 'success') {
+                continue;
+            }
+            const contextPath = join(contextTreeDir, operation.path, 'context.md');
+            if (operation.type === 'ADD') {
+                changes.created.push(contextPath);
+            }
+            else if (operation.type === 'UPDATE') {
+                changes.updated.push(contextPath);
+            }
+        }
+    }
+    return changes;
+}
+/**
+ * Hook that transforms sessionExecutions into ActivityLog format
+ */
+export function useActivityLogs() {
+    const { sessionExecutions } = useConsumer();
+    const logs = useMemo(() => sessionExecutions.map(({ execution, toolCalls }) => {
+        const progress = toolCalls.map((tc) => ({
+            id: tc.id,
+            status: tc.status,
+            toolCallName: tc.name,
+        }));
+        const changes = composeChangesFromToolCalls(toolCalls);
+        const activityLog = {
+            changes,
+            content: execution.status === 'failed' ? execution.error ?? '' : execution.result ?? '',
+            id: execution.id,
+            input: parseExecutionContent(execution.input),
+            progress,
+            source: 'agent',
+            status: execution.status,
+            timestamp: new Date(execution.updatedAt),
+            type: execution.type,
+        };
+        return activityLog;
+    }), [sessionExecutions]);
+    return { logs };
+}

package/dist/tui/hooks/use-consumer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Consumer Hook
+ *
+ * Hook to manage consumer lifecycle
+ */
+import type { ConsumerStatus } from '../types.js';
+export declare function useConsumer(): {
+    consumerError: Error | null;
+    consumerId: null | string;
+    consumerStatus: ConsumerStatus;
+    restart: () => Promise<void>;
+};

package/dist/tui/hooks/use-consumer.js

@@ -0,0 +1,50 @@
+/**
+ * Consumer Hook
+ *
+ * Hook to manage consumer lifecycle
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { ConsumerService } from '../../infra/cipher/consumer/consumer-service.js';
+export function useConsumer() {
+    const [status, setStatus] = useState('starting');
+    const [consumerError, setConsumerError] = useState(null);
+    const [consumerId, setConsumerId] = useState(null);
+    const consumerRef = useRef(new ConsumerService());
+    const mountedRef = useRef(true);
+    const startConsumer = useCallback(async () => {
+        try {
+            setStatus('starting');
+            setConsumerError(null);
+            await consumerRef.current.start();
+            if (mountedRef.current) {
+                setStatus('running');
+                setConsumerId(consumerRef.current.getConsumerId());
+            }
+        }
+        catch (error) {
+            if (mountedRef.current) {
+                setStatus('error');
+                setConsumerError(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }, []);
+    const restart = useCallback(async () => {
+        // Dispose current consumer
+        consumerRef.current.dispose();
+        setStatus('stopped');
+        setConsumerId(null);
+        // Create new consumer and start
+        consumerRef.current = new ConsumerService();
+        await startConsumer();
+    }, [startConsumer]);
+    useEffect(() => {
+        mountedRef.current = true;
+        startConsumer();
+        return () => {
+            mountedRef.current = false;
+            consumerRef.current.dispose();
+            setStatus('stopped');
+        };
+    }, [startConsumer]);
+    return { consumerError, consumerId, consumerStatus: status, restart };
+}

package/dist/tui/hooks/use-onboarding.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Onboarding Hook
+ *
+ * Re-exports from onboarding context for backward compatibility.
+ */
+export { OnboardingProvider, useOnboarding } from '../contexts/onboarding-context.js';
+export type { OnboardingStep, OnboardingContextValue as UseOnboardingReturn } from '../contexts/onboarding-context.js';

package/dist/tui/hooks/use-onboarding.js

@@ -0,0 +1,6 @@
+/**
+ * Onboarding Hook
+ *
+ * Re-exports from onboarding context for backward compatibility.
+ */
+export { OnboardingProvider, useOnboarding } from '../contexts/onboarding-context.js';

package/dist/tui/hooks/use-queue-polling.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Queue Polling Hook
+ *
+ * React hook for subscribing to QueuePollingService events
+ *
+ * Architecture:
+ * - Connects to singleton QueuePollingService
+ * - Updates React state only when data changes
+ * - Cleans up on unmount
+ * - Prevents memory leaks via singleton pattern
+ *
+ * Usage in Ink component:
+ * ```tsx
+ * const { stats, sessionExecutions, error } = useQueuePolling({ consumerId })
+ * ```
+ */
+import type { ExecutionWithToolCalls, QueueStats } from '../../infra/cipher/consumer/queue-polling-service.js';
+export declare function useQueuePolling(options?: {
+    consumerId?: string;
+    pollInterval?: number;
+}): {
+    error: Error | null;
+    isConnected: boolean;
+    reconnectCount: number;
+    sessionExecutions: ExecutionWithToolCalls[];
+    stats: null | QueueStats;
+};
+/**
+ * Cleanup hook - call when dashboard unmounts
+ */
+export declare function useQueuePollingCleanup(): () => void;

package/dist/tui/hooks/use-queue-polling.js

@@ -0,0 +1,90 @@
+/**
+ * Queue Polling Hook
+ *
+ * React hook for subscribing to QueuePollingService events
+ *
+ * Architecture:
+ * - Connects to singleton QueuePollingService
+ * - Updates React state only when data changes
+ * - Cleans up on unmount
+ * - Prevents memory leaks via singleton pattern
+ *
+ * Usage in Ink component:
+ * ```tsx
+ * const { stats, sessionExecutions, error } = useQueuePolling({ consumerId })
+ * ```
+ */
+import { useEffect, useState } from 'react';
+import { getQueuePollingService, stopQueuePollingService } from '../../infra/cipher/consumer/queue-polling-service.js';
+export function useQueuePolling(options) {
+    const [stats, setStats] = useState(null);
+    const [sessionExecutions, setSessionExecutions] = useState([]);
+    const [error, setError] = useState(null);
+    const [isConnected, setIsConnected] = useState(false);
+    const [reconnectCount, setReconnectCount] = useState(0);
+    useEffect(() => {
+        const service = getQueuePollingService({ pollInterval: options?.pollInterval });
+        // Update consumerId when it changes (e.g., after consumer starts)
+        if (options?.consumerId) {
+            service.setConsumerId(options.consumerId);
+        }
+        // Subscribe to events
+        const handleSnapshot = (snapshot) => {
+            setStats(snapshot.stats);
+            setSessionExecutions(snapshot.sessionExecutions);
+            setIsConnected(true);
+        };
+        const handleError = (err) => {
+            setError(err);
+        };
+        const handleStopped = () => {
+            setIsConnected(false);
+        };
+        const handleReconnected = () => {
+            // Clear error on successful reconnect
+            setError(null);
+            setReconnectCount((prev) => prev + 1);
+        };
+        service.on('snapshot', handleSnapshot);
+        service.on('error', handleError);
+        service.on('stopped', handleStopped);
+        service.on('reconnected', handleReconnected);
+        // Start service if not running
+        if (service.isRunning()) {
+            // Get current snapshot immediately
+            const current = service.getCurrentSnapshot();
+            if (current) {
+                handleSnapshot(current);
+            }
+        }
+        else {
+            service.start().catch((error_) => {
+                setError(error_ instanceof Error ? error_ : new Error(String(error_)));
+            });
+        }
+        // Cleanup on unmount
+        return () => {
+            service.off('snapshot', handleSnapshot);
+            service.off('error', handleError);
+            service.off('stopped', handleStopped);
+            service.off('reconnected', handleReconnected);
+            // Note: Don't stop service here - other components may be using it
+            // Service is stopped via stopQueuePollingService() when app exits
+        };
+    }, [options?.consumerId, options?.pollInterval]);
+    return {
+        error,
+        isConnected,
+        reconnectCount,
+        sessionExecutions,
+        stats,
+    };
+}
+/**
+ * Cleanup hook - call when dashboard unmounts
+ */
+export function useQueuePollingCleanup() {
+    return () => {
+        stopQueuePollingService();
+    };
+}

package/dist/tui/hooks/use-slash-command-processor.d.ts

@@ -0,0 +1,16 @@
+import type { CommandContext, SlashCommand, SlashCommandActionReturn } from '../types.js';
+/**
+ * Hook return type
+ */
+interface UseSlashCommandProcessorReturn {
+    /** Handle a slash command input */
+    handleSlashCommand: (input: string) => Promise<SlashCommandActionReturn>;
+    /** Whether a command is currently being processed */
+    isProcessing: boolean;
+}
+/**
+ * Hook for processing slash commands
+ * Handles command parsing, execution, and result handling
+ */
+export declare function useSlashCommandProcessor(context: CommandContext, commands: readonly SlashCommand[]): UseSlashCommandProcessorReturn;
+export {};

package/dist/tui/hooks/use-slash-command-processor.js

@@ -0,0 +1,132 @@
+import { useCallback, useState } from 'react';
+import { splitArgs } from '../../infra/repl/commands/arg-parser.js';
+/**
+ * Parse user input to extract command, subcommand, and arguments
+ */
+function parseInput(input, commands) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/')) {
+        return { args: trimmed, isCommand: false };
+    }
+    const withoutSlash = trimmed.slice(1);
+    const parts = withoutSlash.split(/\s+/);
+    const commandName = parts[0]?.toLowerCase();
+    if (!commandName) {
+        return { args: '', isCommand: true };
+    }
+    // Find command by name or alias
+    const command = commands.find((cmd) => cmd.name === commandName || cmd.aliases?.includes(commandName));
+    if (!command) {
+        return { args: parts.slice(1).join(' '), isCommand: true };
+    }
+    // Check for subcommand
+    if (command.subCommands?.length && parts.length > 1) {
+        const subCommandName = parts[1]?.toLowerCase();
+        const subCommand = command.subCommands.find((sub) => sub.name === subCommandName || sub.aliases?.includes(subCommandName));
+        if (subCommand) {
+            return {
+                args: parts.slice(2).join(' '),
+                command,
+                isCommand: true,
+                subCommand,
+            };
+        }
+    }
+    return {
+        args: parts.slice(1).join(' '),
+        command,
+        isCommand: true,
+    };
+}
+/**
+ * Hook for processing slash commands
+ * Handles command parsing, execution, and result handling
+ */
+export function useSlashCommandProcessor(context, commands) {
+    const [isProcessing, setIsProcessing] = useState(false);
+    const handleSlashCommand = useCallback(async (input) => {
+        const { args, command, isCommand, subCommand } = parseInput(input, commands);
+        if (!isCommand) {
+            // Slash command only mode - show warning for non-slash input
+            return {
+                content: 'Please use a slash command. Type / for available commands.',
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        if (!command) {
+            const commandName = input.trim().slice(1).split(/\s+/)[0];
+            return {
+                content: `Unknown command: /${commandName}. Type / for available commands.`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        // Determine which action to execute
+        const actionToExecute = subCommand?.action ?? command.action;
+        const commandNameForContext = subCommand ? `${command.name} ${subCommand.name}` : command.name;
+        if (!actionToExecute) {
+            // Command has no action and no matching subcommand
+            if (command.subCommands?.length) {
+                const subNames = command.subCommands.map((s) => s.name).join('|');
+                return {
+                    content: `Usage: /${command.name} <${subNames}>`,
+                    messageType: 'error',
+                    type: 'message',
+                };
+            }
+            return {
+                content: `Command /${command.name} has no action defined.`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        // Check for required arguments
+        const targetCommand = subCommand ?? command;
+        const requiredArgs = targetCommand.args?.filter((arg) => arg.required) ?? [];
+        if (requiredArgs.length > 0 && !args.trim()) {
+            const argNames = requiredArgs.map((a) => `<${a.name}>`).join(' ');
+            const flagsStr = targetCommand.flags?.map((f) => `[--${f.name}]`).join(' ') ?? '';
+            const usage = `/${commandNameForContext} ${argNames}${flagsStr ? ' ' + flagsStr : ''}`;
+            return {
+                content: `Missing required argument(s).\nUsage: ${usage}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        // Extract file references from args
+        const { args: argsWithoutFiles, files } = splitArgs(args);
+        const cleanArgs = argsWithoutFiles.join(' ');
+        // Build execution context with invocation details
+        const execContext = {
+            ...context,
+            invocation: {
+                args: cleanArgs,
+                files,
+                name: commandNameForContext,
+                raw: input,
+            },
+            slashCommands: commands,
+        };
+        setIsProcessing(true);
+        try {
+            const result = await actionToExecute(execContext, cleanArgs);
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Error executing /${commandNameForContext}: ${errorMessage}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }, [commands, context]);
+    return {
+        handleSlashCommand,
+        isProcessing,
+    };
+}

package/dist/tui/hooks/use-slash-completion.d.ts

@@ -0,0 +1,30 @@
+import type { CommandSuggestion } from '../types.js';
+/**
+ * Hook return type
+ */
+interface UseSlashCompletionReturn {
+    /** Index of currently active suggestion (-1 if none) */
+    activeIndex: number;
+    /** Clear suggestions */
+    clearSuggestions: () => void;
+    /** Whether the input matches a known command (even if typing arguments) */
+    hasMatchedCommand: boolean;
+    /** Whether input is a slash command attempt (starts with /) */
+    isCommandAttempt: boolean;
+    /** Move to next suggestion */
+    nextSuggestion: () => void;
+    /** Move to previous suggestion */
+    prevSuggestion: () => void;
+    /** Select the current suggestion and return the value to insert */
+    selectSuggestion: () => null | string;
+    /** Set active index directly */
+    setActiveIndex: (index: number) => void;
+    /** Current suggestions */
+    suggestions: CommandSuggestion[];
+}
+/**
+ * Hook for slash command auto-completion
+ * Generates suggestions based on input and manages selection state
+ */
+export declare function useSlashCompletion(input: string): UseSlashCompletionReturn;
+export {};