wave-code 0.0.2

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "wave-code",
+  "version": "0.0.2",
+  "description": "CLI-based code assistant powered by AI, built with React and Ink",
+  "keywords": [
+    "ai",
+    "cli",
+    "code-assistant",
+    "react",
+    "ink",
+    "typescript"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "wave-code": "bin/wave-code.js",
+    "wave": "bin/wave-code.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "dependencies": {
+    "ink": "^6.0.1",
+    "react": "^19.1.0",
+    "yargs": "^17.7.2",
+    "diff": "^8.0.2",
+    "glob": "^11.0.3",
+    "wave-agent-sdk": "0.0.2"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.8",
+    "@types/yargs": "^17.0.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "ink-testing-library": "^4.0.0",
+    "rimraf": "^6.0.1",
+    "tsc-alias": "^1.8.16",
+    "tsx": "^4.20.4",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "type-check": "tsc --noEmit --incremental",
+    "dev": "tsc -p tsconfig.build.json --watch & tsc-alias -p tsconfig.build.json --watch",
+    "test": "vitest run",
+    "lint": "eslint --cache",
+    "format": "prettier --write ."
+  }
+}

package/src/cli.tsx

@@ -0,0 +1,82 @@
+import React from "react";
+import { render } from "ink";
+import { App } from "./components/App.js";
+import { cleanupLogs } from "./utils/logger.js";
+
+export interface CliOptions {
+  restoreSessionId?: string;
+  continueLastSession?: boolean;
+}
+
+export async function startCli(options: CliOptions): Promise<void> {
+  const { restoreSessionId, continueLastSession } = options;
+
+  // Continue with ink-based UI for normal mode
+  // Global cleanup tracker
+  let isCleaningUp = false;
+  let appUnmounted = false;
+
+  const cleanup = async () => {
+    if (isCleaningUp) return;
+    isCleaningUp = true;
+
+    console.log("\nShutting down gracefully...");
+
+    try {
+      // Clean up old log files
+      await cleanupLogs().catch((error) => {
+        console.warn("Failed to cleanup old logs:", error);
+      });
+
+      // Unmount the React app to trigger cleanup
+      if (!appUnmounted) {
+        unmount();
+        appUnmounted = true;
+        // Give React time to cleanup
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+
+      process.exit(0);
+    } catch (error: unknown) {
+      console.error("Error during cleanup:", error);
+      process.exit(1);
+    }
+  };
+
+  // Handle process signals
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+
+  // Handle uncaught exceptions
+  process.on("uncaughtException", (error) => {
+    console.error("Uncaught exception:", error);
+    cleanup();
+  });
+
+  process.on("unhandledRejection", (reason, promise) => {
+    console.error("Unhandled rejection at:", promise, "reason:", reason);
+    cleanup();
+  });
+
+  // Render the application
+  const { unmount } = render(
+    <App
+      restoreSessionId={restoreSessionId}
+      continueLastSession={continueLastSession}
+    />,
+  );
+
+  // Store unmount function for cleanup when process exits normally
+  process.on("exit", () => {
+    if (!appUnmounted) {
+      try {
+        unmount();
+      } catch {
+        // Ignore errors during unmount
+      }
+    }
+  });
+
+  // Return a promise that never resolves to keep the CLI running
+  return new Promise(() => {});
+}

package/src/components/App.tsx

@@ -0,0 +1,31 @@
+import React from "react";
+import { ChatInterface } from "./ChatInterface.js";
+import { ChatProvider } from "../contexts/useChat.js";
+import { AppProvider } from "../contexts/useAppConfig.js";
+
+interface AppProps {
+  restoreSessionId?: string;
+  continueLastSession?: boolean;
+}
+
+const AppWithProviders: React.FC = () => {
+  return (
+    <ChatProvider>
+      <ChatInterface />
+    </ChatProvider>
+  );
+};
+
+export const App: React.FC<AppProps> = ({
+  restoreSessionId,
+  continueLastSession,
+}) => {
+  return (
+    <AppProvider
+      restoreSessionId={restoreSessionId}
+      continueLastSession={continueLastSession}
+    >
+      <AppWithProviders />
+    </AppProvider>
+  );
+};

package/src/components/BashHistorySelector.tsx

@@ -0,0 +1,163 @@
+import React, { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import { searchBashHistory, type BashHistoryEntry } from "wave-agent-sdk";
+import { logger } from "../utils/logger.js";
+
+export interface BashHistorySelectorProps {
+  searchQuery: string;
+  workdir: string;
+  onSelect: (command: string) => void;
+  onExecute: (command: string) => void;
+  onCancel: () => void;
+}
+
+export const BashHistorySelector: React.FC<BashHistorySelectorProps> = ({
+  searchQuery,
+  workdir,
+  onSelect,
+  onExecute,
+  onCancel,
+}) => {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [commands, setCommands] = useState<BashHistoryEntry[]>([]);
+
+  // Search bash history
+  useEffect(() => {
+    const results = searchBashHistory(searchQuery, 10, workdir);
+    setCommands(results);
+    setSelectedIndex(0);
+    logger.debug("Bash history search:", {
+      searchQuery,
+      workdir,
+      resultCount: results.length,
+    });
+  }, [searchQuery, workdir]);
+
+  useInput((input, key) => {
+    logger.debug("BashHistorySelector useInput:", {
+      input,
+      key,
+      commandsLength: commands.length,
+      selectedIndex,
+    });
+
+    if (key.return) {
+      if (commands.length > 0 && selectedIndex < commands.length) {
+        const selectedCommand = commands[selectedIndex];
+        onExecute(selectedCommand.command);
+      } else if (commands.length === 0 && searchQuery.trim()) {
+        // When no history records match, execute the search query as a new command
+        onExecute(searchQuery.trim());
+      }
+      return;
+    }
+
+    if (key.tab) {
+      if (commands.length > 0 && selectedIndex < commands.length) {
+        const selectedCommand = commands[selectedIndex];
+        onSelect(selectedCommand.command);
+      } else if (commands.length === 0 && searchQuery.trim()) {
+        // When no history records match, insert the search query
+        onSelect(searchQuery.trim());
+      }
+      return;
+    }
+
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+
+    if (key.upArrow) {
+      setSelectedIndex(Math.max(0, selectedIndex - 1));
+      return;
+    }
+
+    if (key.downArrow) {
+      setSelectedIndex(Math.min(commands.length - 1, selectedIndex + 1));
+      return;
+    }
+  });
+
+  if (commands.length === 0) {
+    return (
+      <Box
+        flexDirection="column"
+        borderStyle="single"
+        borderColor="yellow"
+        padding={1}
+        marginBottom={1}
+      >
+        <Text color="yellow">
+          No bash history found {searchQuery && `for "${searchQuery}"`}
+        </Text>
+        {searchQuery.trim() && (
+          <Text color="green">Press Enter to execute: {searchQuery}</Text>
+        )}
+        {searchQuery.trim() && (
+          <Text color="blue">Press Tab to insert: {searchQuery}</Text>
+        )}
+        <Text dimColor>Press Escape to cancel</Text>
+      </Box>
+    );
+  }
+
+  const formatTimestamp = (timestamp: number): string => {
+    const date = new Date(timestamp);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const diffDays = Math.floor(diffHours / 24);
+
+    if (diffDays > 0) {
+      return `${diffDays}d ago`;
+    } else if (diffHours > 0) {
+      return `${diffHours}h ago`;
+    } else {
+      const diffMinutes = Math.floor(diffMs / (1000 * 60));
+      return diffMinutes > 0 ? `${diffMinutes}m ago` : "just now";
+    }
+  };
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="single"
+      borderColor="blue"
+      padding={1}
+      gap={1}
+      marginBottom={1}
+    >
+      <Box>
+        <Text color="blue" bold>
+          Bash History {searchQuery && `(filtering: "${searchQuery}")`}
+        </Text>
+      </Box>
+
+      {commands.map((cmd, index) => (
+        <Box key={index} flexDirection="column">
+          <Text
+            color={index === selectedIndex ? "black" : "white"}
+            backgroundColor={index === selectedIndex ? "blue" : undefined}
+          >
+            {cmd.command}
+          </Text>
+          {index === selectedIndex && (
+            <Box marginLeft={4} flexDirection="column">
+              <Text color="gray" dimColor>
+                {formatTimestamp(cmd.timestamp)}
+                {cmd.workdir !== workdir && ` • in ${cmd.workdir}`}
+              </Text>
+            </Box>
+          )}
+        </Box>
+      ))}
+
+      <Box>
+        <Text dimColor>
+          Use ↑↓ to navigate, Enter to execute, Tab to insert, Escape to cancel
+        </Text>
+      </Box>
+    </Box>
+  );
+};

package/src/components/BashShellManager.tsx

@@ -0,0 +1,306 @@
+import React, { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import { useChat } from "../contexts/useChat.js";
+
+interface BashShell {
+  id: string;
+  command: string;
+  status: "running" | "completed" | "killed";
+  startTime: number;
+  exitCode?: number;
+  runtime?: number;
+}
+
+export interface BashShellManagerProps {
+  onCancel: () => void;
+}
+
+export const BashShellManager: React.FC<BashShellManagerProps> = ({
+  onCancel,
+}) => {
+  const { backgroundShells, getBackgroundShellOutput, killBackgroundShell } =
+    useChat();
+  const [shells, setShells] = useState<BashShell[]>([]);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [viewMode, setViewMode] = useState<"list" | "detail">("list");
+  const [detailShellId, setDetailShellId] = useState<string | null>(null);
+  const [detailOutput, setDetailOutput] = useState<{
+    stdout: string;
+    stderr: string;
+    status: string;
+  } | null>(null);
+
+  // Convert backgroundShells to local BashShell format
+  useEffect(() => {
+    setShells(
+      backgroundShells.map((shell) => ({
+        id: shell.id,
+        command: shell.command,
+        status: shell.status,
+        startTime: shell.startTime,
+        exitCode: shell.exitCode,
+        runtime: shell.runtime,
+      })),
+    );
+  }, [backgroundShells]);
+
+  // Load detail output for selected shell
+  useEffect(() => {
+    if (viewMode === "detail" && detailShellId) {
+      const output = getBackgroundShellOutput(detailShellId);
+      setDetailOutput(output);
+    }
+  }, [viewMode, detailShellId, getBackgroundShellOutput]);
+
+  const formatDuration = (ms: number): string => {
+    if (ms < 1000) return `${ms}ms`;
+    if (ms < 60000) return `${Math.round(ms / 1000)}s`;
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.round((ms % 60000) / 1000);
+    return `${minutes}m ${seconds}s`;
+  };
+
+  const formatTime = (timestamp: number): string => {
+    return new Date(timestamp).toLocaleTimeString();
+  };
+
+  const killShell = (shellId: string) => {
+    killBackgroundShell(shellId);
+  };
+
+  useInput((input, key) => {
+    if (viewMode === "list") {
+      // List mode navigation
+      if (key.return) {
+        if (shells.length > 0 && selectedIndex < shells.length) {
+          const selectedShell = shells[selectedIndex];
+          setDetailShellId(selectedShell.id);
+          setViewMode("detail");
+        }
+        return;
+      }
+
+      if (key.escape) {
+        onCancel();
+        return;
+      }
+
+      if (key.upArrow) {
+        setSelectedIndex(Math.max(0, selectedIndex - 1));
+        return;
+      }
+
+      if (key.downArrow) {
+        setSelectedIndex(Math.min(shells.length - 1, selectedIndex + 1));
+        return;
+      }
+
+      if (input === "k" && shells.length > 0 && selectedIndex < shells.length) {
+        const selectedShell = shells[selectedIndex];
+        if (selectedShell.status === "running") {
+          killShell(selectedShell.id);
+        }
+        return;
+      }
+    } else if (viewMode === "detail") {
+      // Detail mode navigation
+      if (key.escape) {
+        setViewMode("list");
+        setDetailShellId(null);
+        setDetailOutput(null);
+        return;
+      }
+
+      if (input === "k" && detailShellId) {
+        const shell = shells.find((s) => s.id === detailShellId);
+        if (shell && shell.status === "running") {
+          killShell(detailShellId);
+        }
+        return;
+      }
+    }
+  });
+
+  if (viewMode === "detail" && detailShellId && detailOutput) {
+    const shell = shells.find((s) => s.id === detailShellId);
+    if (!shell) {
+      setViewMode("list");
+      return null;
+    }
+
+    return (
+      <Box
+        flexDirection="column"
+        borderStyle="single"
+        borderColor="cyan"
+        padding={1}
+        gap={1}
+        marginBottom={1}
+      >
+        <Box>
+          <Text color="cyan" bold>
+            Background Shell Details: {shell.id}
+          </Text>
+        </Box>
+
+        <Box flexDirection="column" gap={1}>
+          <Box>
+            <Text>
+              <Text color="blue">Command:</Text> {shell.command}
+            </Text>
+          </Box>
+          <Box>
+            <Text>
+              <Text color="blue">Status:</Text> {shell.status}
+              {shell.exitCode !== undefined &&
+                ` (exit code: ${shell.exitCode})`}
+            </Text>
+          </Box>
+          <Box>
+            <Text>
+              <Text color="blue">Started:</Text> {formatTime(shell.startTime)}
+              {shell.runtime !== undefined && (
+                <Text>
+                  {" "}
+                  | <Text color="blue">Runtime:</Text>{" "}
+                  {formatDuration(shell.runtime)}
+                </Text>
+              )}
+            </Text>
+          </Box>
+        </Box>
+
+        {detailOutput.stdout && (
+          <Box flexDirection="column" marginTop={1}>
+            <Text color="green" bold>
+              STDOUT (last 10 lines):
+            </Text>
+            <Box borderStyle="single" borderColor="green" padding={1}>
+              <Text>
+                {detailOutput.stdout.split("\n").slice(-10).join("\n")}
+              </Text>
+            </Box>
+          </Box>
+        )}
+
+        {detailOutput.stderr && (
+          <Box flexDirection="column" marginTop={1}>
+            <Text color="red" bold>
+              STDERR:
+            </Text>
+            <Box borderStyle="single" borderColor="red" padding={1}>
+              <Text color="red">
+                {detailOutput.stderr.split("\n").slice(-10).join("\n")}
+              </Text>
+            </Box>
+          </Box>
+        )}
+
+        <Box marginTop={1}>
+          <Text dimColor>
+            {shell.status === "running" ? "k to kill · " : ""}Esc to go back
+          </Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  if (!backgroundShells) {
+    return (
+      <Box
+        flexDirection="column"
+        borderStyle="single"
+        borderColor="cyan"
+        padding={1}
+        marginBottom={1}
+      >
+        <Text color="cyan" bold>
+          Background Bash Shells
+        </Text>
+        <Text>Background bash shells not available</Text>
+        <Text dimColor>Press Escape to close</Text>
+      </Box>
+    );
+  }
+
+  if (shells.length === 0) {
+    return (
+      <Box
+        flexDirection="column"
+        borderStyle="single"
+        borderColor="cyan"
+        padding={1}
+        marginBottom={1}
+      >
+        <Text color="cyan" bold>
+          Background Bash Shells
+        </Text>
+        <Text>No background shells found</Text>
+        <Text dimColor>Press Escape to close</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="single"
+      borderColor="cyan"
+      padding={1}
+      gap={1}
+      marginBottom={1}
+    >
+      <Box>
+        <Text color="cyan" bold>
+          Background Bash Shells
+        </Text>
+      </Box>
+      <Text dimColor>Select a shell to view details</Text>
+
+      {shells.map((shell, index) => (
+        <Box key={shell.id} flexDirection="column">
+          <Text
+            color={index === selectedIndex ? "black" : "white"}
+            backgroundColor={index === selectedIndex ? "cyan" : undefined}
+          >
+            {index === selectedIndex ? "▶ " : "  "}
+            {index + 1}.{" "}
+            {shell.command.length > 50
+              ? shell.command.substring(0, 47) + "..."
+              : shell.command}
+            <Text
+              color={
+                shell.status === "running"
+                  ? "green"
+                  : shell.status === "completed"
+                    ? "blue"
+                    : "red"
+              }
+            >
+              {" "}
+              ({shell.status})
+            </Text>
+          </Text>
+          {index === selectedIndex && (
+            <Box marginLeft={4} flexDirection="column">
+              <Text color="gray" dimColor>
+                ID: {shell.id} | Started: {formatTime(shell.startTime)}
+                {shell.runtime !== undefined &&
+                  ` | Runtime: ${formatDuration(shell.runtime)}`}
+                {shell.exitCode !== undefined && ` | Exit: ${shell.exitCode}`}
+              </Text>
+            </Box>
+          )}
+        </Box>
+      ))}
+
+      <Box marginTop={1}>
+        <Text dimColor>
+          ↑/↓ to select · Enter to view ·{" "}
+          {shells[selectedIndex]?.status === "running" ? "k to kill · " : ""}Esc
+          to close
+        </Text>
+      </Box>
+    </Box>
+  );
+};