godspeed-agent 0.1.0

package/src/providers/openrouter.ts

@@ -0,0 +1,97 @@
+import type { LLMProvider } from "./types.js";
+
+export const openrouterProvider: LLMProvider = {
+  name: "openrouter",
+
+  async generate({ apiKey, model, messages }) {
+    const res = await fetch(
+      "https://openrouter.ai/api/v1/chat/completions",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          model,
+          messages: messages.map((m) => ({
+            role: m.role === "model" ? "assistant" : "user",
+            content: m.text,
+          })),
+        }),
+      },
+    );
+
+    if (!res.ok) {
+      throw new Error(await res.text());
+    }
+
+    const data: any = await res.json();
+
+    return data.choices?.[0]?.message?.content ?? "";
+  },
+
+  async stream({ apiKey, model, prompt, onToken }) {
+    const res = await fetch(
+      "https://openrouter.ai/api/v1/chat/completions",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          model,
+          stream: true,
+          messages: [
+            {
+              role: "user",
+              content: prompt,
+            },
+          ],
+        }),
+      },
+    );
+
+    if (!res.ok || !res.body) {
+      throw new Error(await res.text());
+    }
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        if (!trimmed.startsWith("data: ")) continue;
+
+        const jsonText = trimmed.replace("data: ", "");
+
+        if (jsonText === "[DONE]") continue;
+
+        try {
+          const data = JSON.parse(jsonText);
+
+          const token =
+            data.choices?.[0]?.delta?.content;
+
+          if (token) {
+            onToken(token);
+          }
+        } catch {}
+      }
+    }
+  },
+};

package/src/providers/types.ts

@@ -0,0 +1,18 @@
+import type { ChatMessage } from "../lib/llm.js";
+
+export type LLMProvider = {
+  name: string;
+
+  generate: (params: {
+    apiKey: string;
+    model: string;
+    messages: ChatMessage[];
+  }) => Promise<string>;
+
+  stream?: (params: {
+    apiKey: string;
+    model: string;
+    prompt: string;
+    onToken: (token: string) => void;
+  }) => Promise<void>;
+};

package/src/tools/labels.ts

@@ -0,0 +1,38 @@
+import type { ToolAction } from "./registry.js";
+
+export function getToolLabel(action: ToolAction) {
+  switch (action.action) {
+    case "WRITE_FILE":
+      return `WRITE_FILE ${action.path}`;
+
+    case "EDIT_FILE":
+      return `EDIT_FILE ${action.path}`;
+
+    case "DELETE_FILE":
+      return `DELETE_FILE ${action.path}`;
+
+    case "CREATE_DIRECTORY":
+      return `CREATE_DIRECTORY ${action.path}`;
+
+    case "MOVE_FILE":
+      return `MOVE_FILE ${action.from} -> ${action.to}`;
+
+    case "COPY_FILE":
+      return `COPY_FILE ${action.from} -> ${action.to}`;
+
+    case "RUN_COMMAND":
+      return `RUN_COMMAND ${action.command}`;
+
+    case "READ_FILE":
+      return `READ_FILE ${action.path}`;
+
+    case "LIST_FILES":
+      return `LIST_FILES ${action.path ?? "."}`;
+
+    case "GLOB_FILES":
+      return `GLOB_FILES ${action.pattern}`;
+
+    case "SEARCH_FILES":
+      return `SEARCH_FILES ${action.query}`;
+  }
+}

package/src/tools/metadata.ts

@@ -0,0 +1,102 @@
+export const TOOL_DEFINITIONS = [
+  {
+    name: "LIST_FILES",
+    description: "List files in a directory",
+    example: {
+      action: "LIST_FILES",
+      path: ".",
+    },
+  },
+
+  {
+    name: "READ_FILE",
+    description: "Read file contents",
+    example: {
+      action: "READ_FILE",
+      path: "package.json",
+    },
+  },
+
+  {
+    name: "WRITE_FILE",
+    description: "Create or overwrite a file",
+    example: {
+      action: "WRITE_FILE",
+      path: "hello.txt",
+      content: "hello world",
+    },
+  },
+
+  {
+    name: "RUN_COMMAND",
+    description: "Run safe terminal commands",
+    example: {
+      action: "RUN_COMMAND",
+      command: "bun test",
+    },
+  },
+
+  {
+    name: "GLOB_FILES",
+    description: "Find files by glob pattern",
+    example: {
+      action: "GLOB_FILES",
+      pattern: "src/**/*.ts",
+    },
+  },
+
+  {
+    name: "SEARCH_FILES",
+    description: "Search text inside project files",
+    example: {
+      action: "SEARCH_FILES",
+      query: "askLLMWithMessages",
+    },
+  },
+  {
+    name: "EDIT_FILE",
+    description: "Edit a file by replacing exact text with new text",
+    example: {
+      action: "EDIT_FILE",
+      path: "src/index.ts",
+      find: "console.log('hello');",
+      replace: "console.log('hello world');",
+    },
+  },
+  {
+    name: "DELETE_FILE",
+    description: "Delete a file inside the workspace",
+    example: {
+      action: "DELETE_FILE",
+      path: "hello.txt",
+    },
+  },
+  {
+    name: "CREATE_DIRECTORY",
+    description: "Create a directory inside the workspace",
+    example: {
+      action: "CREATE_DIRECTORY",
+      path: "src/components",
+    },
+  },
+
+  {
+    name: "MOVE_FILE",
+    description: "Move or rename a file inside the workspace",
+    example: {
+      action: "MOVE_FILE",
+      from: "old.txt",
+      to: "new.txt",
+    },
+  },
+
+  {
+    name: "COPY_FILE",
+    description: "Copy a file inside the workspace",
+    example: {
+      action: "COPY_FILE",
+      from: "hello.txt",
+      to: "backup/hello.txt",
+    },
+  },
+];

package/src/tools/prompt.ts

@@ -0,0 +1,37 @@
+import { TOOL_DEFINITIONS } from "./metadata.js";
+
+export function buildSystemPrompt() {
+  const tools = TOOL_DEFINITIONS.map(
+    (tool) =>
+      `
+Tool: ${tool.name}
+Description: ${tool.description}
+
+Example:
+${JSON.stringify(tool.example, null, 2)}
+`
+  ).join("\n");
+
+  return `
+You are a coding agent.
+
+You can ONLY respond with valid JSON.
+
+Available tools:
+
+${tools}
+
+Final answer:
+
+{
+  "action": "FINAL",
+  "answer": "your answer"
+}
+
+Rules:
+- Return ONLY JSON.
+- Never use markdown.
+- Use tools when necessary.
+- Use FINAL only when the task is complete.
+`;
+}

package/src/tools/registry.ts

@@ -0,0 +1,63 @@
+import {
+  listFiles,
+  readFile,
+  writeFile,
+  runCommand,
+  globFiles,
+  searchFiles,
+  editFile,
+  deleteFile,
+  createDirectory,
+  moveFile,
+  copyFile,
+} from "./tools.js";
+
+export type ToolAction =
+  | { action: "LIST_FILES"; path?: string }
+  | { action: "READ_FILE"; path: string }
+  | { action: "WRITE_FILE"; path: string; content: string }
+  | { action: "DELETE_FILE"; path: string }
+  | { action: "EDIT_FILE"; path: string; find: string; replace: string }
+  | { action: "CREATE_DIRECTORY"; path: string }
+  | { action: "MOVE_FILE"; from: string; to: string }
+  | { action: "COPY_FILE"; from: string; to: string }
+  | { action: "RUN_COMMAND"; command: string }
+  | { action: "GLOB_FILES"; pattern: string }
+  | { action: "SEARCH_FILES"; query: string };
+
+export async function executeTool(action: ToolAction) {
+  switch (action.action) {
+    case "LIST_FILES":
+      return listFiles(action.path ?? ".");
+
+    case "READ_FILE":
+      return readFile(action.path);
+
+    case "WRITE_FILE":
+      return writeFile(action.path, action.content);
+
+    case "DELETE_FILE":
+      return deleteFile(action.path);
+
+    case "EDIT_FILE":
+      return editFile(action.path, action.find, action.replace);
+
+    case "CREATE_DIRECTORY":
+      return createDirectory(action.path);
+
+    case "MOVE_FILE":
+      return moveFile(action.from, action.to);
+
+    case "COPY_FILE":
+      return copyFile(action.from, action.to);
+
+    case "RUN_COMMAND":
+      return runCommand(action.command);
+
+    case "GLOB_FILES":
+      return await globFiles(action.pattern);
+
+    case "SEARCH_FILES":
+      return await searchFiles(action.query);
+  }
+}

package/src/tools/tools.ts

@@ -0,0 +1,179 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { getWorkspace, resolveWorkspacePath } from "./workspace.js";
+import fg from "fast-glob";
+
+export function listFiles(dir = ".") {
+  const fullPath = resolveWorkspacePath(dir);
+  return fs.readdirSync(fullPath).join("\n");
+}
+
+export function readFile(filePath: string) {
+  const fullPath = resolveWorkspacePath(filePath);
+  return fs.readFileSync(fullPath, "utf-8");
+}
+
+export function writeFile(filePath: string, content: string) {
+  const fullPath = resolveWorkspacePath(filePath); 
+  
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, content, "utf-8");
+
+  return `File written: ${filePath}`;
+}
+
+export function runCommand(command: string) {
+  const allowedCommands = [
+    "ls",
+    "pwd",
+    "cat",
+    "echo",
+    "mkdir",
+    "touch",
+    "bun",
+    "node",
+    "npm",
+    "git",
+  ];
+
+
+  const first = command.trim().split(/\s+/)[0];
+  
+  if (!first) {
+    throw new Error("Empty command");
+  }
+  
+  if (!allowedCommands.includes(first)) {
+    throw new Error(`Blocked command: ${first}`);
+  }
+  
+  if (!allowedCommands.includes(first)) {
+    throw new Error(`Blocked command: ${first}`);
+  }
+
+  return execSync(command, {
+    cwd: getWorkspace(),
+    encoding: "utf-8",
+    timeout: 10_000,
+  });
+}
+export async function globFiles(pattern: string) {
+  const files = await fg(pattern, {
+    cwd: getWorkspace(),
+    onlyFiles: true,
+    dot: true,
+    ignore: ["node_modules/**", ".git/**", "dist/**"],
+  });
+
+  return files.join("\n");
+}
+
+export async function searchFiles(query: string) {
+  const files = await fg("**/*", {
+    cwd: getWorkspace(),
+    onlyFiles: true,
+    dot: true,
+    ignore: ["node_modules/**", ".git/**", "dist/**", "bun.lock"],
+  });
+
+  const matches: string[] = [];
+
+  for (const file of files) {
+    const fullPath = resolveWorkspacePath(file);
+
+    let content = "";
+
+    try {
+      content = fs.readFileSync(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+
+    const lines = content.split("\n");
+
+    lines.forEach((line, index) => {
+      if (line.toLowerCase().includes(query.toLowerCase())) {
+        matches.push(`${file}:${index + 1}: ${line.trim()}`);
+      }
+    });
+  }
+
+  return matches.length > 0
+    ? matches.join("\n")
+    : `No matches found for: ${query}`;
+}
+
+
+
+
+export function editFile(filePath: string, find: string, replace: string) {
+  const fullPath = resolveWorkspacePath(filePath);
+
+  const content = fs.readFileSync(fullPath, "utf-8");
+
+  if (!content.includes(find)) {
+    throw new Error(`Text not found in file: ${filePath}`);
+  }
+
+  const updated = content.replace(find, replace);
+
+  fs.writeFileSync(fullPath, updated, "utf-8");
+
+  return `Edited file: ${filePath}`;
+}
+
+export function deleteFile(filePath: string) {
+  const fullPath = resolveWorkspacePath(filePath);
+
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const stat = fs.statSync(fullPath);
+
+  if (!stat.isFile()) {
+    throw new Error(`Not a file: ${filePath}`);
+  }
+
+  fs.unlinkSync(fullPath);
+
+  return `Deleted file: ${filePath}`;
+}
+
+
+export function createDirectory(dirPath: string) {
+  const fullPath = resolveWorkspacePath(dirPath);
+
+  fs.mkdirSync(fullPath, { recursive: true });
+
+  return `Directory created: ${dirPath}`;
+}
+
+export function moveFile(from: string, to: string) {
+  const fromPath = resolveWorkspacePath(from);
+  const toPath = resolveWorkspacePath(to);
+
+  if (!fs.existsSync(fromPath)) {
+    throw new Error(`Source not found: ${from}`);
+  }
+
+  fs.mkdirSync(path.dirname(toPath), { recursive: true });
+  fs.renameSync(fromPath, toPath);
+
+  return `Moved: ${from} -> ${to}`;
+}
+
+export function copyFile(from: string, to: string) {
+  const fromPath = resolveWorkspacePath(from);
+  const toPath = resolveWorkspacePath(to);
+
+  if (!fs.existsSync(fromPath)) {
+    throw new Error(`Source not found: ${from}`);
+  }
+
+  fs.mkdirSync(path.dirname(toPath), { recursive: true });
+  fs.copyFileSync(fromPath, toPath);
+
+  return `Copied: ${from} -> ${to}`;
+}

package/src/tools/workspace.ts

@@ -0,0 +1,22 @@
+import path from "path";
+
+let WORKSPACE = process.cwd();
+
+export function setWorkspace(workspacePath: string) {
+  WORKSPACE = path.resolve(workspacePath);
+}
+
+export function getWorkspace() {
+  return WORKSPACE;
+}
+
+export function resolveWorkspacePath(filePath: string) {
+  const fullPath = path.resolve(WORKSPACE, filePath);
+  const relative = path.relative(WORKSPACE, fullPath);
+
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error("Blocked: path outside workspace");
+  }
+
+  return fullPath;
+}