codebase-rag-tui 0.1.0

package/dist/api/chat.d.ts

@@ -0,0 +1,4 @@
+export declare function sendMessage(question: string, socketId: string, sessionId?: string): Promise<{
+    session_id: string;
+    response: string;
+}>;

package/dist/api/chat.js

@@ -0,0 +1,14 @@
+export async function sendMessage(question, socketId, sessionId) {
+    const res = await fetch(`${process.env['BACKEND_URI']}/remote/repo/query`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json", // Add this!
+        },
+        body: JSON.stringify({
+            question: question,
+            socket_id: socketId,
+            session_id: sessionId,
+        })
+    });
+    return res.json();
+}

package/dist/api/gemini.d.ts

@@ -0,0 +1,3 @@
+import { type ChatSession } from '@google/generative-ai';
+export declare function initGemini(apiKey: string): ChatSession;
+export declare function sendMessage(chat: ChatSession, text: string): Promise<string>;

package/dist/api/gemini.js

@@ -0,0 +1,10 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+export function initGemini(apiKey) {
+    const genAI = new GoogleGenerativeAI(apiKey);
+    const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' });
+    return model.startChat();
+}
+export async function sendMessage(chat, text) {
+    const result = await chat.sendMessage(text);
+    return result.response.text();
+}

package/dist/app.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function App(): React.JSX.Element;

package/dist/app.js

@@ -0,0 +1,105 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useApp } from 'ink';
+import Header from './components/Header.js';
+import Message from './components/Message.js';
+import Input from './components/Input.js';
+import { sendMessage } from './api/chat.js';
+import { useSocket } from './contexts/SocketContext.js';
+import { getWorkspaceInfo } from './utils/workspace.js';
+import { useWorkspace } from './contexts/WorkspaceContext.js';
+export default function App() {
+    const { exit } = useApp();
+    const { socket, isConnected, isConnecting, connectionError } = useSocket();
+    const { workspace, setWorkspace } = useWorkspace();
+    const [messages, setMessages] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [sessionId, setSessionId] = useState(null);
+    const welcomeMessage = 'Start you session by entering the path to your repository';
+    useEffect(() => {
+        setMessages([{ role: 'model', text: welcomeMessage }]);
+    }, []); // Only run once on mount
+    const handleSubmit = async (text) => {
+        if (text === '/help') {
+            const helpText = `Available commands:
+• /help - Show this help message
+• /clear - Clear conversation
+• /quit - Leave current session and reset workspace
+• /exit - Exit the application`;
+            setMessages((prev) => [...prev, { role: 'model', text: helpText }]);
+        }
+        if (text === '/exit') {
+            exit();
+            socket?.disconnect();
+            return;
+        }
+        if (text === '/clear') {
+            setMessages([]);
+            return;
+        }
+        if (text === '/quit') {
+            setSessionId(null);
+            setWorkspace(process.cwd());
+            setMessages([{ role: 'model', text: welcomeMessage }]);
+            return;
+        }
+        setMessages((prev) => [...prev, { role: 'user', text }]);
+        if (workspace == process.cwd()) {
+            try {
+                const info = await getWorkspaceInfo(text);
+                if (info.exists && info.isDirectory) {
+                    setWorkspace(info.absolutePath);
+                    setMessages((prev) => [...prev, { role: 'model', text: `Workspace is set to: ${info.absolutePath}` }]);
+                }
+                else if (info.exists) {
+                    setMessages((prev) => [...prev, { role: 'model', text: 'Path exists but is not a directory. Please enter a valid directory path.' }]);
+                }
+                else {
+                    setMessages((prev) => [...prev, { role: 'model', text: 'Directory does not exist. Please enter a valid project directory path.' }]);
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : 'Unknown error occurred';
+                setMessages((prev) => [...prev, { role: 'model', text: `Error validating path: ${message}` }]);
+            }
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        if (!socket || !isConnected || !socket.id) {
+            setMessages((prev) => [...prev, { role: 'model', text: 'Failed to connect to server' }]);
+            return;
+        }
+        try {
+            if (sessionId) {
+                const res = await sendMessage(text, socket.id, sessionId);
+                setMessages((prev) => [...prev, { role: 'model', text: res.response }]);
+            }
+            else {
+                const res = await sendMessage(text, socket.id);
+                setSessionId(res.session_id);
+                setMessages((prev) => [...prev, { role: 'model', text: res.response }]);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error occurred';
+            setError(`Error: ${message}`);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Header, null),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, messages.map((msg, i) => (
+        // eslint-disable-next-line react/no-array-index-key
+        React.createElement(Message, { key: i, role: msg.role, text: msg.text })))),
+        (error || connectionError) && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "red" }, error || connectionError))),
+        isConnecting && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "yellow" }, "Connecting to server..."))),
+        !isConnected && !isConnecting && !connectionError && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "gray" }, "Disconnected from server"))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Input, { onSubmit: handleSubmit, isLoading: isLoading }))));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import App from './app.js';
+import { SocketProvider } from './contexts/SocketContext.js';
+import { WorkspaceProvider } from './contexts/WorkspaceContext.js';
+import { config } from 'dotenv';
+config();
+render(React.createElement(WorkspaceProvider, null,
+    React.createElement(SocketProvider, null,
+        React.createElement(App, null))));

package/dist/components/Header.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Header(): React.JSX.Element;

package/dist/components/Header.js

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export default function Header() {
+    return (React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1 },
+        React.createElement(Text, { bold: true, color: "cyan" }, "Codebase RAG Agent")));
+}

package/dist/components/Input.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    onSubmit: (value: string) => void;
+    isLoading: boolean;
+};
+export default function Input({ onSubmit, isLoading }: Props): React.JSX.Element;
+export {};

package/dist/components/Input.js

@@ -0,0 +1,20 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+export default function Input({ onSubmit, isLoading }) {
+    const [value, setValue] = useState('');
+    const handleSubmit = (text) => {
+        if (text.trim().length === 0) {
+            return;
+        }
+        onSubmit(text.trim());
+        setValue('');
+    };
+    if (isLoading) {
+        return (React.createElement(Box, null,
+            React.createElement(Text, { dimColor: true }, "Thinking...")));
+    }
+    return (React.createElement(Box, null,
+        React.createElement(Text, { bold: true, color: "green" }, '> '),
+        React.createElement(TextInput, { value: value, onChange: setValue, onSubmit: handleSubmit, placeholder: "Type a message...", focus: !isLoading })));
+}

package/dist/components/Message.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    role: 'user' | 'model';
+    text: string;
+};
+export default function Message({ role, text }: Props): React.JSX.Element;
+export {};

package/dist/components/Message.js

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export default function Message({ role, text }) {
+    if (role === 'user') {
+        return (React.createElement(Box, null,
+            React.createElement(Text, { color: "green" },
+                '> ',
+                text)));
+    }
+    return (React.createElement(Box, null,
+        React.createElement(Text, { color: "blue" },
+            "Codebase Rag Agent: ",
+            text)));
+}

package/dist/contexts/SocketContext.d.ts

@@ -0,0 +1,18 @@
+import React, { ReactNode } from 'react';
+import { Socket } from 'socket.io-client';
+interface SocketContextType {
+    socket: Socket | null;
+    isConnected: boolean;
+    isConnecting: boolean;
+    connectionError: string | null;
+    connect: () => void;
+    disconnect: () => void;
+}
+declare const SocketContext: React.Context<SocketContextType | undefined>;
+interface SocketProviderProps {
+    children: ReactNode;
+    serverUrl?: string;
+}
+export declare const SocketProvider: React.FC<SocketProviderProps>;
+export declare const useSocket: () => SocketContextType;
+export default SocketContext;

package/dist/contexts/SocketContext.js

@@ -0,0 +1,120 @@
+import React, { createContext, useContext, useEffect, useState, useRef } from 'react';
+import { io } from 'socket.io-client';
+import { listDirectory, readFileBytes, readFileText, writeFile } from '../utils/file-operations.js';
+import { useWorkspace } from './WorkspaceContext.js';
+import { runCommand } from '../utils/shell-operations.js';
+const SocketContext = createContext(undefined);
+export const SocketProvider = ({ children, serverUrl = process.env['BACKEND_URI'], }) => {
+    const [socket, setSocket] = useState(null);
+    const [isConnected, setIsConnected] = useState(false);
+    const [isConnecting, setIsConnecting] = useState(false);
+    const [connectionError, setConnectionError] = useState(null);
+    const { workspace } = useWorkspace();
+    const workspaceRef = useRef(workspace);
+    useEffect(() => { workspaceRef.current = workspace; }, [workspace]);
+    const connect = () => {
+        if (socket && socket.connected) {
+            return; // Already connected
+        }
+        setIsConnecting(true);
+        setConnectionError(null);
+        const newSocket = io(serverUrl, {
+            autoConnect: true,
+            reconnection: true,
+            reconnectionAttempts: 5,
+            reconnectionDelay: 1000,
+        });
+        newSocket.on('connect', () => {
+            setIsConnected(true);
+            setIsConnecting(false);
+            setConnectionError(null);
+        });
+        newSocket.on('disconnect', (reason) => {
+            setIsConnected(false);
+            setIsConnecting(false);
+            if (reason === 'io server disconnect') {
+                // Server initiated disconnect, don't reconnect automatically
+                setConnectionError('Server disconnected');
+            }
+        });
+        newSocket.on('connect_error', (error) => {
+            setIsConnecting(false);
+            setConnectionError(`Failed to connect: ${error.message}`);
+        });
+        newSocket.on('reconnect', () => {
+            setIsConnected(true);
+            setIsConnecting(false);
+            setConnectionError(null);
+        });
+        newSocket.on('reconnect_error', (error) => {
+            setConnectionError(`Reconnection failed: ${error.message}`);
+        });
+        newSocket.on('reconnect_failed', () => {
+            setIsConnecting(false);
+            setConnectionError('Failed to reconnect to server');
+        });
+        // File system event handlers
+        newSocket.on('dir:list', async (payload, ack) => {
+            console.log('dir:list event heard');
+            const result = await listDirectory(payload.dir_path, workspaceRef.current);
+            ack(result);
+        });
+        newSocket.on('bytes:read', async (payload, ack) => {
+            console.log('bytes:read event heard');
+            const result = await readFileBytes(payload.file_path, workspaceRef.current);
+            ack(result);
+        });
+        newSocket.on('file:read', async (payload, ack) => {
+            console.log('file:read event heard');
+            const result = await readFileText(payload.file_path, workspaceRef.current);
+            ack(result);
+        });
+        newSocket.on('file:write', async (payload, ack) => {
+            console.log('file:write event heard');
+            const result = await writeFile(payload.file_path, payload.content, workspaceRef.current);
+            ack(result);
+        });
+        newSocket.on("command:run", async (payload, ack) => {
+            const res = await runCommand(payload.cmd_parts, workspace, payload.timeout);
+            ack(res);
+        });
+        setSocket(newSocket);
+    };
+    const disconnect = () => {
+        if (socket) {
+            socket.disconnect();
+            setSocket(null);
+            setIsConnected(false);
+            setIsConnecting(false);
+            setConnectionError(null);
+        }
+    };
+    useEffect(() => {
+        // Auto-connect on mount if serverUrl is available
+        if (serverUrl) {
+            connect();
+        }
+        return () => {
+            if (socket) {
+                socket.disconnect();
+            }
+        };
+    }, [serverUrl]);
+    const value = {
+        socket,
+        isConnected,
+        isConnecting,
+        connectionError,
+        connect,
+        disconnect,
+    };
+    return (React.createElement(SocketContext.Provider, { value: value }, children));
+};
+export const useSocket = () => {
+    const context = useContext(SocketContext);
+    if (context === undefined) {
+        throw new Error('useSocket must be used within a SocketProvider');
+    }
+    return context;
+};
+export default SocketContext;

package/dist/contexts/WorkspaceContext.d.ts

@@ -0,0 +1,10 @@
+import React, { ReactNode } from 'react';
+interface WorkspaceContextType {
+    workspace: string;
+    setWorkspace: (newPath: string) => void;
+}
+export declare const WorkspaceProvider: ({ children }: {
+    children: ReactNode;
+}) => React.JSX.Element;
+export declare const useWorkspace: () => WorkspaceContextType;
+export {};

package/dist/contexts/WorkspaceContext.js

@@ -0,0 +1,17 @@
+import React, { createContext, useContext, useState } from 'react';
+const WorkspaceContext = createContext(undefined);
+export const WorkspaceProvider = ({ children }) => {
+    const [workspace, setWorkspace] = useState(process.cwd());
+    const value = {
+        workspace,
+        setWorkspace,
+    };
+    return (React.createElement(WorkspaceContext.Provider, { value: value }, children));
+};
+export const useWorkspace = () => {
+    const context = useContext(WorkspaceContext);
+    if (!context) {
+        throw new Error('WorkspacePath must be used within a WorkspaceProvider');
+    }
+    return context;
+};

package/dist/utils/file-operations.d.ts

@@ -0,0 +1,21 @@
+export interface FileSystemResult {
+    ok: boolean;
+    content?: string | Uint8Array;
+    error?: string;
+}
+/**
+ * List contents of a directory
+ */
+export declare function listDirectory(dirPath: string, workspace: string): Promise<FileSystemResult>;
+/**
+ * Read file as raw bytes
+ */
+export declare function readFileBytes(filePath: string, workspace: string): Promise<FileSystemResult>;
+/**
+ * Read file as UTF-8 text
+ */
+export declare function readFileText(filePath: string, workspace: string): Promise<FileSystemResult>;
+/**
+ * Write content to file
+ */
+export declare function writeFile(filePath: string, content: string, workspace: string): Promise<FileSystemResult>;

package/dist/utils/file-operations.js

@@ -0,0 +1,58 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * List contents of a directory
+ */
+export async function listDirectory(dirPath, workspace) {
+    try {
+        const fullPath = workspace ? path.join(workspace, dirPath) : dirPath;
+        const entries = await fs.readdir(fullPath, { withFileTypes: true });
+        const content = entries.map(entry => entry.name).join('\n');
+        return { ok: true, content };
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+}
+/**
+ * Read file as raw bytes
+ */
+export async function readFileBytes(filePath, workspace) {
+    try {
+        const fullPath = workspace ? path.join(workspace, filePath) : filePath;
+        const content = await fs.readFile(fullPath);
+        return { ok: true, content };
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+}
+/**
+ * Read file as UTF-8 text
+ */
+export async function readFileText(filePath, workspace) {
+    try {
+        const fullPath = workspace ? path.join(workspace, filePath) : filePath;
+        const content = await fs.readFile(fullPath, 'utf8');
+        return { ok: true, content };
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+}
+/**
+ * Write content to file
+ */
+export async function writeFile(filePath, content, workspace) {
+    try {
+        const fullPath = workspace ? path.join(workspace, filePath) : filePath;
+        const parentDir = path.dirname(fullPath);
+        // Create parent directory if it doesn't exist
+        await fs.mkdir(parentDir, { recursive: true });
+        await fs.writeFile(fullPath, content, 'utf8');
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+}

package/dist/utils/shell-operations.d.ts

@@ -0,0 +1,7 @@
+interface ShellCommandResult {
+    return_code: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function runCommand(cmd_parts: string[], cwd: string, timeout: number): Promise<ShellCommandResult>;
+export {};

package/dist/utils/shell-operations.js

@@ -0,0 +1,55 @@
+import { spawn } from 'child_process';
+export async function runCommand(cmd_parts, cwd, timeout) {
+    return new Promise((resolve) => {
+        if (cmd_parts.length === 0) {
+            resolve({
+                return_code: -1,
+                stdout: '',
+                stderr: 'Command array is empty.'
+            });
+            return;
+        }
+        const [command, ...args] = cmd_parts;
+        // 1. Create the subprocess
+        const process = spawn(command, args, {
+            cwd: cwd,
+            shell: false // Use false for security if using cmd_parts array
+        });
+        let stdout = '';
+        let stderr = '';
+        // 2. Set up a timeout timer
+        const timer = setTimeout(() => {
+            process.kill();
+            resolve({
+                return_code: -1,
+                stdout: '',
+                stderr: `Command timed out after ${timeout / 1000} seconds.`
+            });
+        }, timeout);
+        // 3. Capture output
+        process.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        process.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        // 4. Handle completion
+        process.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({
+                return_code: code ?? -1,
+                stdout: stdout.trim(),
+                stderr: stderr.trim()
+            });
+        });
+        // 5. Handle immediate execution errors (e.g., command not found)
+        process.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({
+                return_code: -1,
+                stdout: '',
+                stderr: err.message
+            });
+        });
+    });
+}

package/dist/utils/workspace.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Validates if a given path is a valid directory
+ */
+export declare function isValidDirectory(dirPath: string): Promise<boolean>;
+/**
+ * Resolves a path relative to the current working directory
+ */
+export declare function resolvePath(inputPath: string): string;
+/**
+ * Gets basic info about a workspace directory
+ */
+export declare function getWorkspaceInfo(dirPath: string): Promise<{
+    exists: boolean;
+    isDirectory: boolean;
+    absolutePath: string;
+    name: string;
+}>;

package/dist/utils/workspace.js

@@ -0,0 +1,44 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Validates if a given path is a valid directory
+ */
+export async function isValidDirectory(dirPath) {
+    try {
+        const stats = await fs.stat(dirPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolves a path relative to the current working directory
+ */
+export function resolvePath(inputPath) {
+    return path.resolve(inputPath);
+}
+/**
+ * Gets basic info about a workspace directory
+ */
+export async function getWorkspaceInfo(dirPath) {
+    const absolutePath = resolvePath(dirPath);
+    const name = path.basename(absolutePath);
+    try {
+        const stats = await fs.stat(absolutePath);
+        return {
+            exists: true,
+            isDirectory: stats.isDirectory(),
+            absolutePath,
+            name
+        };
+    }
+    catch {
+        return {
+            exists: false,
+            isDirectory: false,
+            absolutePath,
+            name
+        };
+    }
+}

package/package.json

@@ -0,0 +1,83 @@
+{
+	"name": "codebase-rag-tui",
+	"version": "0.1.0",
+	"description": "Terminal-based AI agent for codebase RAG (Retrieval-Augmented Generation)",
+	"license": "MIT",
+	"author": "johnsonafool",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/johnsonafool/codebase-rag-tui.git"
+	},
+	"homepage": "https://github.com/johnsonafool/codebase-rag-tui#readme",
+	"bugs": {
+		"url": "https://github.com/johnsonafool/codebase-rag-tui/issues"
+	},
+	"keywords": [
+		"cli",
+		"terminal",
+		"ai",
+		"rag",
+		"codebase",
+		"tui",
+		"ink",
+		"react"
+	],
+	"bin": {
+		"codebase-rag-tui": "dist/cli.js"
+	},
+	"type": "module",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"prepublishOnly": "pnpm build",
+		"test": "prettier --check . && xo && ava"
+	},
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"@google/generative-ai": "^0.24.1",
+		"dotenv": "^17.2.4",
+		"ink": "^4.1.0",
+		"ink-text-input": "^6.0.0",
+		"meow": "^11.0.0",
+		"react": "^18.2.0",
+		"socket.io": "^4.8.3",
+		"socket.io-client": "^4.8.3"
+	},
+	"devDependencies": {
+		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/react": "^18.0.32",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"ava": "^5.2.0",
+		"chalk": "^5.2.0",
+		"eslint-config-xo-react": "^0.27.0",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^4.6.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^2.8.7",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.0.3",
+		"xo": "^0.53.1"
+	},
+	"ava": {
+		"extensions": {
+			"ts": "module",
+			"tsx": "module"
+		},
+		"nodeArguments": [
+			"--loader=ts-node/esm"
+		]
+	},
+	"xo": {
+		"extends": "xo-react",
+		"prettier": true,
+		"rules": {
+			"react/prop-types": "off"
+		}
+	},
+	"prettier": "@vdemedes/prettier-config"
+}

package/readme.md

@@ -0,0 +1,58 @@
+# codebase-rag-tui
+
+A terminal-based AI agent for codebase RAG (Retrieval-Augmented Generation). Built with [Ink](https://github.com/vadimdemedes/ink) (React for the terminal).
+
+## Install
+
+```bash
+npm install -g codebase-rag-tui
+```
+
+## Configuration
+
+Set the following environment variables:
+
+```bash
+export BACKEND_URI=http://localhost:3000
+export GEMINI_API_KEY=your-gemini-api-key
+```
+
+Or create a `.env` file in the directory where you run the command:
+
+```
+BACKEND_URI=http://localhost:3000
+GEMINI_API_KEY=your-gemini-api-key
+```
+
+## Usage
+
+```bash
+codebase-rag-tui
+```
+
+The app will prompt you to enter the path to your repository, then you can start asking questions about your codebase.
+
+## Commands
+
+| Command  | Description                              |
+| -------- | ---------------------------------------- |
+| `/help`  | Show help message                        |
+| `/clear` | Wipe the chat history                    |
+| `/quit`  | Leave current session and reset workspace|
+| `/exit`  | Quit the application                     |
+
+## Development
+
+```bash
+pnpm install
+pnpm dev       # watch mode
+node dist/cli.js
+```
+
+## Tech Stack
+
+- **TypeScript** + **React** via [Ink](https://github.com/vadimdemedes/ink)
+- **Socket.IO** for real-time communication with the backend
+- **Google Gemini API** for AI responses
+- **ink-text-input** for terminal text input
+- **dotenv** for environment configuration