woopcode 0.1.0

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "woopcode",
+  "version": "0.1.0",
+  "description": "An autonomous AI coding assistant built for the terminal",
+  "license": "MIT",
+  "author": {
+    "name": "Manas Raghuwanshi",
+    "url": "https://github.com/mangit955"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mangit955/woop-code.git"
+  },
+  "homepage": "https://github.com/mangit955/woop-code#readme",
+  "bugs": {
+    "url": "https://github.com/mangit955/woop-code/issues"
+  },
+  "keywords": [
+    "ai",
+    "coding-assistant",
+    "cli",
+    "terminal",
+    "autonomous-agent",
+    "llm",
+    "gemini",
+    "bun",
+    "typescript",
+    "developer-tools",
+    "code-generation",
+    "ai-agent"
+  ],
+  "bin": {
+    "woopcode": "./cli.ts"
+  },
+  "main": "./cli.ts",
+  "type": "module",
+  "files": [
+    "cli.ts",
+    "commands/",
+    "config/",
+    "tools/",
+    "tui/",
+    "onboarding/",
+    "README.md",
+    "LICENSE",
+    "CONTRIBUTING.md"
+  ],
+  "scripts": {
+    "start": "bun ./cli.ts",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "prepublishOnly": "bun test"
+  },
+  "dependencies": {
+    "@google/genai": "^2.12.0",
+    "@inkjs/ui": "^2.0.0",
+    "chalk": "^5.6.2",
+    "cli-highlight": "^2.1.11",
+    "commander": "^12.0.0",
+    "diff": "^9.0.0",
+    "ink": "^7.1.1",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "marked": "^18.0.7",
+    "react": "^19.2.7",
+    "woopcode": "file:woopcode-0.1.0.tgz"
+  },
+  "devDependencies": {
+    "@stryker-mutator/core": "^9.6.1",
+    "@stryker-mutator/typescript-checker": "^9.6.1",
+    "@types/bun": "latest",
+    "@types/commander": "^2.12.5",
+    "@types/react": "^19.2.17",
+    "fast-check": "^4.9.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/tools/createFile.ts

@@ -0,0 +1,24 @@
+import type { Tool } from "../config/types";
+import { existsSync } from "fs";
+
+export const createFileTool: Tool = {
+  name: "create_file",
+  description: "Creates a new file with the provided content.",
+  parameters: [
+    { name: "path", description: "File path", required: true },
+    { name: "content", description: "File content", required: true },
+  ],
+  async execute(args) {
+    const path = args.path as string;
+    const content = args.content as string;
+
+    if (!path) throw new Error("Missing required argument: path");
+    if (!content) throw new Error("Missing required argument: content");
+
+    if (existsSync(path)) {
+      throw new Error(`File already exists: ${path}`);
+    }
+    await Bun.write(path, content);
+    return `Created file: ${path}`;
+  },
+};

package/tools/editFile.ts

@@ -0,0 +1,85 @@
+import type { Tool } from "../config/types";
+import { createTwoFilesPatch } from "diff";
+import { store } from "../tui/src/store/ui-store";
+import type { PendingEdit } from "../tui/src/types";
+
+export const editFileTool: Tool = {
+  name: "edit_file",
+  description: "Replace text inside an existing file.",
+
+  parameters: [
+    {
+      name: "path",
+      description: "File path",
+      required: true,
+    },
+    {
+      name: "oldText",
+      description: "Text to replace",
+      required: true,
+    },
+    {
+      name: "newText",
+      description: "Replacement text",
+      required: true,
+    },
+  ],
+
+  async execute(args) {
+    const path = args.path as string;
+    const oldText = args.oldText as string;
+    const newText = args.newText as string;
+
+    const file = Bun.file(path);
+
+    if (!(await file.exists())) {
+      throw new Error(`File not found: ${path}`);
+    }
+
+    const content = await file.text();
+
+    if (!content.includes(oldText)) {
+      throw new Error("Text to replace not found.");
+    }
+
+    const updated = content.replace(oldText, newText);
+
+    // If content is identical, skip diff preview
+    if (content === updated) {
+      return `No changes needed for ${path}`;
+    }
+
+    // Generate unified diff
+    const diff = createTwoFilesPatch(path, path, content, updated, "", "", {
+      context: 3,
+    });
+
+    // Create pending edit
+    const pendingEdit: PendingEdit = {
+      id: crypto.randomUUID(),
+      filePath: path,
+      oldContent: content,
+      newContent: updated,
+      diff,
+      toolCallId: crypto.randomUUID(),
+    };
+
+    // Request approval from UI
+    let approved: boolean;
+    try {
+      approved = await store.setPendingEdit(pendingEdit);
+    } catch (error) {
+      // User cancelled with Esc
+      return `Edit cancelled for ${path}`;
+    }
+
+    if (!approved) {
+      return `Edit rejected for ${path}`;
+    }
+
+    // Write file after approval
+    await Bun.write(path, updated);
+
+    return `Edited ${path}`;
+  },
+};

package/tools/findFiles.ts

@@ -0,0 +1,94 @@
+import type { Tool } from "../config/types";
+
+export const findFilesTool: Tool = {
+  name: "find_files",
+  description: "Finds files by name or partial filename.",
+  parameters: [
+    {
+      name: "query",
+      required: true,
+      description: "filename or partial filename",
+    },
+    {
+      name: "path",
+      required: false,
+      description: "root directory, default process.cwd()",
+    },
+  ],
+  async execute(args) {
+    const query = args.query;
+    if (!query || typeof query !== "string") {
+      throw new Error("Parameter 'query' is required and must be a string.");
+    }
+    const rootPath =
+      args.path && typeof args.path === "string" ? args.path : process.cwd();
+
+    const matches: string[] = [];
+    const lowerQuery = query.toLowerCase();
+
+    const glob = new Bun.Glob("**/*");
+    for await (const entry of glob.scan(rootPath)) {
+      const parts = entry.split("/");
+      if (
+        parts.some((part) =>
+          [
+            ".git",
+            "node_modules",
+            "dist",
+            "build",
+            ".next",
+            "coverage",
+          ].includes(part),
+        )
+      ) {
+        continue;
+      }
+      const basename = parts.at(-1);
+      if (!basename) {
+        continue;
+      }
+      if (
+        [
+          "bun.lock",
+          "package-lock.json",
+          "pnpm-lock.yaml",
+          "yarn.lock",
+        ].includes(basename)
+      ) {
+        continue;
+      }
+      if (
+        basename.toLowerCase().includes(lowerQuery) ||
+        entry.toLowerCase().includes(lowerQuery)
+      ) {
+        // Only include files, not directories
+        const fullPath = `${rootPath}/${entry}`;
+        try {
+          const stat = await Bun.file(fullPath).stat();
+          if (!stat.isDirectory) {
+            matches.push(entry);
+          }
+        } catch {
+          // If we can't stat it, skip it
+          continue;
+        }
+      }
+    }
+
+    if (matches.length === 0) {
+      return "No matching files found.";
+    }
+
+    const output = matches.join("\n");
+    const MAX_OUTPUT_SIZE = 8 * 1024; // 8 KB
+
+    if (output.length <= MAX_OUTPUT_SIZE) {
+      return output;
+    }
+
+    return (
+      output.slice(0, MAX_OUTPUT_SIZE) +
+      `\n\n... output truncated (${matches.length} matches found)`
+    );
+  },
+};

package/tools/grep.ts

@@ -0,0 +1,68 @@
+import type { Tool } from "../config/types";
+
+export const grepTool: Tool = {
+  name: "grep",
+  description: "Searches recursively for text in project files.",
+  parameters: [
+    { name: "pattern", required: true, description: "text to search for" },
+    {
+      name: "path",
+      required: false,
+      description: "directory to search, default process.cwd()",
+    },
+  ],
+  async execute(args) {
+    const pattern = args.pattern;
+    if (!pattern || typeof pattern !== "string") {
+      throw new Error("Parameter 'pattern' is required and must be a string.");
+    }
+
+    const path =
+      args.path && typeof args.path === "string" ? args.path : process.cwd();
+
+    const proc = Bun.spawn({
+      cmd: [
+        "grep",
+        "-RIn",
+        "--exclude-dir=node_modules",
+        "--exclude-dir=.git",
+        "--exclude-dir=dist",
+        "--exclude-dir=build",
+        "--exclude-dir=.next",
+        "--exclude-dir=coverage",
+        "--exclude=bun.lock",
+        "--exclude=package-lock.json",
+        "--exclude=pnpm-lock.yaml",
+        "--exclude=yarn.lock",
+        pattern,
+        path,
+      ],
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.stderr.text(),
+      proc.exited,
+    ]);
+
+    if (exitCode === 1) {
+      return "No matches found.";
+    }
+    if (exitCode > 1) {
+      throw new Error(stderr);
+    }
+    const MAX_OUTPUT_SIZE = 8 * 1024;
+
+    if (stdout.length <= MAX_OUTPUT_SIZE) {
+      return stdout;
+    }
+
+    return (
+      stdout.slice(0, MAX_OUTPUT_SIZE) +
+      `\n\n... Output truncated (${stdout.length - MAX_OUTPUT_SIZE} more bytes). ` +
+      `Refine your search or use read_file on a specific file.`
+    );
+  },
+};

package/tools/index.ts

@@ -0,0 +1,26 @@
+import { terminalTool } from "./terminal";
+import { readFileTool } from "./readFile";
+import { listFilesTool } from "./listFiles";
+import type { Tool } from "../config/types";
+import { createFileTool } from "./createFile";
+import { writeFileTool } from "./writeFile";
+import { editFileTool } from "./editFile";
+import { grepTool } from "./grep";
+import { runTestsTool } from "./runTests";
+import { findFilesTool } from "./findFiles";
+
+export const toolRegistery: Tool[] = [
+  listFilesTool,
+  readFileTool,
+  terminalTool,
+  createFileTool,
+  writeFileTool,
+  editFileTool,
+  grepTool,
+  runTestsTool,
+  findFilesTool,
+];
+
+export function getTool(name: string): Tool | undefined {
+  return toolRegistery.find((tool) => tool.name === name);
+}

package/tools/listFiles.ts

@@ -0,0 +1,49 @@
+import type { Tool } from "../config/types";
+
+export const listFilesTool: Tool = {
+  name: "list_Files",
+  description: "List all the files in the directory",
+  parameters: [
+    {
+      name: "path",
+      description: "Directory path",
+      required: false,
+    },
+  ],
+
+  async execute(args) {
+    const path = (args.path as string) || process.cwd();
+
+    const files: string[] = [];
+
+    for await (const file of new Bun.Glob("**/*").scan(path)) {
+      const ignoredDirs = [
+        "node_modules",
+        ".git",
+        "dist",
+        "build",
+        ".next",
+        "coverage",
+      ];
+
+      if (
+        ignoredDirs.some((dir) => file === dir || file.startsWith(`${dir}/`))
+      ) {
+        continue;
+      }
+
+      files.push(file);
+    }
+    const MAX_TOOL_OUTPUT = 8 * 1024; // 8 KB
+    const output = files.join("\n");
+
+    if (output.length <= MAX_TOOL_OUTPUT) {
+      return output;
+    }
+
+    return (
+      output.slice(0, MAX_TOOL_OUTPUT) +
+      `\n\n... Output truncated (${output.length - MAX_TOOL_OUTPUT} more characters)`
+    );
+  },
+};

package/tools/readFile.ts

@@ -0,0 +1,53 @@
+import type { Tool } from "../config/types";
+import { statSync } from "fs";
+
+export const readFileTool: Tool = {
+  name: "read_file",
+  description: "Reads the contents of a file.",
+  parameters: [
+    {
+      name: "path",
+      description: "Path to the file",
+      required: true,
+    },
+  ],
+
+  async execute(args) {
+    const path = args.path as string;
+
+    if (!path) {
+      throw Error("File path is required");
+    }
+
+    const file = Bun.file(path);
+
+    if (!(await file.exists())) {
+      throw Error(`File ${path} does not exist`);
+    }
+
+    // Check if path is a directory
+    try {
+      const stats = statSync(path);
+      if (stats.isDirectory()) {
+        throw Error(`Cannot read ${path}: it is a directory. Use list_files to see directory contents.`);
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.includes('is a directory')) {
+        throw err;
+      }
+      // If stat fails for other reasons, continue trying to read
+    }
+
+    const MAX_OUTPUT = 16 * 1024; // 16 KB
+    const content = await file.text();
+
+    if (content.length > MAX_OUTPUT) {
+      return (
+        content.slice(0, MAX_OUTPUT) +
+        `\n\n... File truncated. Showing first ${MAX_OUTPUT} characters of ${content.length}.`
+      );
+    }
+
+    return content;
+  },
+};

package/tools/runTests.ts

@@ -0,0 +1,29 @@
+import type { Tool } from "../config/types";
+
+export const runTestsTool: Tool = {
+  name: "run_tests",
+  description: "Runs the project's test command.",
+  parameters: [
+    { name: "command", required: false, description: "defaults to bun test" },
+  ],
+  async execute(args) {
+    const command =
+      args.command && typeof args.command === "string"
+        ? args.command
+        : "bun test";
+
+    const proc = Bun.spawn({
+      cmd: ["sh", "-c", command],
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      proc.stdout.text(),
+      proc.stderr.text(),
+      proc.exited,
+    ]);
+
+    return `Exit code: ${exitCode}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${stderr}`;
+  },
+};

package/tools/terminal.ts

@@ -0,0 +1,37 @@
+import type { Tool } from "../config/types";
+
+export const terminalTool: Tool = {
+  name: "run_terminal",
+  description: "Runs a terminal command in the current project.",
+  parameters: [
+    {
+      name: "command",
+      description: "Command to execute",
+      required: true,
+    },
+  ],
+
+  async execute(args) {
+    const command = args.command as string;
+
+    if (!command) {
+      throw Error("command is required");
+    }
+
+    const proc = Bun.spawn({
+      cmd: ["sh", "-c", command],
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+
+    await proc.exited;
+
+    if (stderr) {
+      return stderr;
+    }
+    return stdout;
+  },
+};

package/tools/writeFile.ts

@@ -0,0 +1,75 @@
+import type { Tool } from "../config/types";
+import { createTwoFilesPatch } from "diff";
+import { store } from "../tui/src/store/ui-store";
+import type { PendingEdit } from "../tui/src/types";
+
+export const writeFileTool: Tool = {
+  name: "write_file",
+
+  description: "Overwrite an existing file.",
+
+  parameters: [
+    {
+      name: "path",
+      description: "File path",
+      required: true,
+    },
+    {
+      name: "content",
+      description: "New file contents",
+      required: true,
+    },
+  ],
+
+  async execute(args) {
+    const path = args.path as string;
+    const content = args.content as string;
+
+    const file = Bun.file(path);
+
+    if (!(await file.exists())) {
+      throw new Error(`File not found: ${path}`);
+    }
+
+    // Read current content
+    const oldContent = await file.text();
+
+    // If content is identical, skip diff preview
+    if (oldContent === content) {
+      return `No changes needed for ${path}`;
+    }
+
+    // Generate unified diff
+    const diff = createTwoFilesPatch(path, path, oldContent, content, "", "", {
+      context: 3,
+    });
+
+    // Create pending edit
+    const pendingEdit: PendingEdit = {
+      id: crypto.randomUUID(),
+      filePath: path,
+      oldContent,
+      newContent: content,
+      diff,
+      toolCallId: crypto.randomUUID(),
+    };
+
+    // Request approval from UI
+    let approved: boolean;
+    try {
+      approved = await store.setPendingEdit(pendingEdit);
+    } catch (error) {
+      // User cancelled with Esc
+      return `Edit cancelled for ${path}`;
+    }
+
+    if (!approved) {
+      return `Edit rejected for ${path}`;
+    }
+
+    // Write file after approval
+    await Bun.write(path, content);
+
+    return `Updated ${path}`;
+  },
+};

package/tui/src/app.tsx

@@ -0,0 +1,60 @@
+import { Box } from "ink";
+import { Header } from "./header";
+import { Timeline } from "./timeline";
+import { ConnectedStatusBar } from "./statusBar";
+import { Prompt } from "./prompt";
+import { useUIStore } from "./store/useUIStore";
+import { HomeScreen, type HomeScreenData } from "./components/HomeScreen";
+import { DiffPreview } from "./components/DiffPreview";
+import type { AgentController } from "../../commands/agentController";
+import { useState } from "react";
+
+interface AppProps {
+  controller: AgentController;
+  onExit: () => Promise<void>;
+  homeScreen: HomeScreenData;
+}
+
+export function App({ controller, onExit, homeScreen }: AppProps) {
+  const state = useUIStore();
+  const [promptValue, setPromptValue] = useState("");
+  const showHome = state.timeline.length === 0;
+  const hasPendingEdit = state.pendingEdit !== null;
+
+  const promptProps = {
+    controller,
+    onExit,
+    value: promptValue,
+    onValueChange: setPromptValue,
+  };
+
+  return (
+    <Box flexDirection="column" height="100%" paddingX={1}>
+      <Box marginBottom={1}>
+        <Header branch={homeScreen.branch} provider={homeScreen.providerName} />
+      </Box>
+
+      <Box flexDirection="column" flexGrow={1} paddingX={1}>
+        {hasPendingEdit ? (
+          <DiffPreview pendingEdit={state.pendingEdit!} />
+        ) : showHome ? (
+          <HomeScreen
+            {...homeScreen}
+            renderPrompt={(placeholder) => (
+              <Prompt {...promptProps} placeholder={placeholder} />
+            )}
+          />
+        ) : (
+          <Timeline items={state.timeline} isThinking={state.isThinking} />
+        )}
+      </Box>
+
+      {!showHome && !hasPendingEdit && (
+        <Box flexDirection="column" marginTop={1}>
+          <ConnectedStatusBar />
+          <Prompt {...promptProps} />
+        </Box>
+      )}
+    </Box>
+  );
+}