godspeed-agent 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bhupesh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+## GodSpeed Agent
+A lightweight AI coding agent built with Bun, TypeScript, Ink, and Gemini/Ollama.
+
+
+
+## feature (v1) :-
+  - Providers
+  - Models
+  - Agent loop
+  - Tool registry
+  - Workspace sandbox
+  - READ_FILE
+  - WRITE_FILE
+  - EDIT_FILE
+  - DELETE_FILE
+  - CREATE_DIRECTORY
+  - MOVE_FILE
+  - COPY_FILE
+  - RUN_COMMAND
+  - GLOB_FILES
+  - SEARCH_FILES
+  - Tool approvals
+  - Agent memory
+  - CLI agent
+  - TUI agent
+  - Direct streaming chat
+  ---------
+inshort - 
+  * Interactive TUI
+  * Agent mode
+  * Tool calling
+  * File editing
+  * Workspace sandboxing
+  * Gemini support
+  * Ollama support
+  * Persistent memory
+  * Multi-provider architecture
+
+  currently supporting these features (v0.1.0)
+
+---
+Installation
+```
+bun add -g godspeed-agent
+```
+
+Usage
+```
+godspeed tui
+```
+```
+godspeed agent -p "create a hello world express server"
+```
+
+----
+
+# Configure Provider
+## gemini
+```
+godspeed providers login -p gemini -k YOUR_API_KEY
+godspeed providers set gemini
+godspeed models set gemini-2.5-flash
+```
+
+## ollama
+```
+godspeed providers login -p ollama -k local
+godspeed providers set ollama
+godspeed models set qwen2.5-coder:3b-instruct-q4_K_M
+```
+
+## openrouter
+```
+godspeed providers login -p openrouter -k YOUR_API_KEY
+godspeed providers set openrouter
+godspeed models set openrouter/free
+```
+
+## Requirements
+- Bun >= 1.0
+
+# Disclaimer
+GodSpeed Agent is an experimental AI-powered coding assistant. While it can generate code, edit files, execute commands, and automate development workflows, it may occasionally produce incorrect, incomplete, insecure, or unexpected results.
+
+Users are responsible for:
+
+* Reviewing all generated code before use.
+* Verifying file modifications and command executions.
+* Testing applications before deploying to production environments.
+* Protecting sensitive information, credentials, and proprietary data.
+
+The authors and contributors of GodSpeed Agent are not responsible for any data loss, security vulnerabilities, system damage, financial loss, or other consequences resulting from the use of this software.
+
+Use GodSpeed Agent at your own risk. It is recommended to use workspace sandboxing, version control, and regular backups when working with important projects.
+
+By installing or using GodSpeed Agent, you acknowledge and accept these limitations and responsibilities.
+
+## License
+This project is licensed under the MIT License. See the [LICENSE](./LICENSE) file for details.

package/bin/godspeed

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../src/cli.ts";

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "godspeed-agent",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "godspeed": "bin/godspeed"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "scripts": {
+    "dev": "bun run src/cli.ts"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "fast-glob": "^3.3.3",
+    "ink": "^7.0.5",
+    "ora": "^9.4.0",
+    "react": "^19.2.7"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.2.16",
+    "typescript": "latest"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { providersCommand } from "./commands/providers.js";
+import { modelsCommand } from "./commands/models.js";
+import { agentCommand } from "./commands/agent.js";
+import { chatCommand } from "./commands/chat.js";
+import { toolsCommand } from "./commands/tools.js";
+import { tuiCommand } from "./commands/tui.js";
+
+const program = new Command();
+
+program
+  .name("tuistarter")
+  .description("Minimal agent CLI from scratch")
+  .version("0.1.0");
+
+program.addCommand(providersCommand);
+program.addCommand(modelsCommand);
+program.addCommand(agentCommand);
+program.addCommand(chatCommand);
+program.addCommand(toolsCommand);
+program.addCommand(tuiCommand);
+
+program.parse();

package/src/commands/agent.ts

@@ -0,0 +1,81 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { runAgent } from "../lib/agent.js";
+import { streamLLM } from "../lib/llm.js";
+import { setWorkspace, getWorkspace } from "../tools/workspace.js";
+import readline from "readline/promises";
+import { stdin, stdout } from "process";
+import { getToolLabel } from "../tools/labels.js";
+
+export const agentCommand = new Command("agent")
+  .description("Run coding agent")
+  .option("-p, --prompt <prompt>", "Prompt to send")
+  .option("-s, --stream", "Stream direct LLM response")
+  .option("-w, --workspace <workspace>", "Workspace path", process.cwd())
+  .action(async (options) => {
+    try {
+      setWorkspace(options.workspace);
+
+      console.log(chalk.gray(`Workspace: ${getWorkspace()}`));
+
+      if (!options.prompt) {
+        console.log(chalk.red("Prompt is required. Use -p or --prompt."));
+        return;
+      }
+
+      if (options.stream) {
+        await streamLLM(options.prompt);
+        return;
+      }
+
+      const answer = await runAgent(options.prompt, {
+        showSpinner: true,
+
+        async confirmTool(action) {
+          const rl = readline.createInterface({
+            input: stdin,
+            output: stdout,
+          });
+
+          const label = getToolLabel(action);
+          
+          const answer = await rl.question(
+            chalk.yellow(`Approve ${label}? (y/n): `),
+          );
+
+          rl.close();
+
+          return answer.trim().toLowerCase() === "y";
+        },
+
+        onStep(step) {
+          const statusIcon =
+            step.status === "completed"
+              ? "✅"
+              : step.status === "failed"
+                ? "❌"
+                : "⏳";
+
+          console.log(
+            chalk.gray(
+              `${statusIcon} Step ${step.step}: ${step.action} ${step.status}`,
+            ),
+          );
+
+          if (step.path) console.log(chalk.gray(`   path: ${step.path}`));
+          if (step.command)
+            console.log(chalk.gray(`   command: ${step.command}`));
+          if (step.pattern)
+            console.log(chalk.gray(`   pattern: ${step.pattern}`));
+          if (step.query) console.log(chalk.gray(`   query: ${step.query}`));
+          if (step.error) console.log(chalk.red(`   error: ${step.error}`));
+        },
+      });
+
+      if (answer) {
+        console.log(answer);
+      }
+    } catch (err) {
+      console.log(chalk.red(err instanceof Error ? err.message : String(err)));
+    }
+  });

package/src/commands/chat.ts

@@ -0,0 +1,65 @@
+import { Command } from "commander";
+import readline from "readline/promises";
+import { stdin, stdout } from "process";
+import chalk from "chalk";
+import { askLLMWithMessages, type ChatMessage } from "../lib/llm.js";
+import { loadHistory, saveHistory, clearHistory } from "../lib/history.js";
+
+export const chatCommand = new Command("chat")
+  .description("Start interactive chat with persistent memory")
+  .option("--session <name>", "Chat session name", "default")
+  .option("--clear", "Clear chat history before starting")
+  .action(async (options) => {
+    const rl = readline.createInterface({
+      input: stdin,
+      output: stdout,
+    });
+
+    if (options.clear) {
+      clearHistory(options.session);
+    }
+
+    const messages: ChatMessage[] = loadHistory(options.session);
+
+    console.log(chalk.green("TUI Starter Chat"));
+    console.log(chalk.gray(`Session: ${options.session}`));
+    console.log(chalk.gray("Type exit or quit to stop.\n"));
+
+    while (true) {
+      const prompt = await rl.question(chalk.cyan("You> "));
+      const cleanedPrompt = prompt.trim();
+
+      if (!cleanedPrompt) continue;
+
+      if (
+        cleanedPrompt.toLowerCase() === "exit" ||
+        cleanedPrompt.toLowerCase() === "quit"
+      ) {
+        break;
+      }
+
+      messages.push({
+        role: "user",
+        text: cleanedPrompt,
+      });
+
+      try {
+        const answer = await askLLMWithMessages(messages);
+
+        messages.push({
+          role: "model",
+          text: answer,
+        });
+
+        saveHistory(options.session, messages);
+
+        console.log(chalk.yellow("\nAI>"));
+        console.log(answer);
+        console.log();
+      } catch (err) {
+        console.log(chalk.red(err instanceof Error ? err.message : String(err)));
+      }
+    }
+
+    rl.close();
+  });

package/src/commands/models.ts

@@ -0,0 +1,49 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig, saveConfig } from "../lib/config.js";
+import { SUPPORTED_PROVIDERS } from "../lib/providers.js";
+
+export const modelsCommand = new Command("models");
+
+modelsCommand
+  .command("list")
+  .description("List models")
+  .action(() => {
+    const config = loadConfig();
+
+    if (!config.activeProvider) {
+      console.log(chalk.red("No active provider selected"));
+      return;
+    }
+
+    const provider = SUPPORTED_PROVIDERS.find(
+      p => p.name === config.activeProvider
+    );
+
+    if (!provider) return;
+
+    for (const model of provider.models) {
+      const active =
+        config.activeModel === model
+          ? chalk.green(" (active)")
+          : "";
+
+      console.log(`- ${model}${active}`);
+    }
+  });
+
+modelsCommand
+  .command("set")
+  .argument("<model>")
+  .description("Set active model")
+  .action((model) => {
+    const config = loadConfig();
+
+    config.activeModel = model;
+
+    saveConfig(config);
+
+    console.log(
+      chalk.green(`Active model set to ${model}`)
+    );
+  });

package/src/commands/providers.ts

@@ -0,0 +1,83 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { getConfigPath, loadConfig, saveConfig } from "../lib/config.js";
+
+export const providersCommand = new Command("providers")
+  .description("Manage API providers");
+
+providersCommand
+  .command("list")
+  .description("List configured providers")
+  .action(() => {
+    const config = loadConfig();
+    const names = Object.keys(config.providers);
+
+    console.log(chalk.gray(`Config: ${getConfigPath()}`));
+
+    if (names.length === 0) {
+      console.log(chalk.yellow("No providers configured yet."));
+      return;
+    }
+
+    for (const name of names) {
+      const active = config.activeProvider === name ? chalk.green(" active") : "";
+      console.log(`- ${name}${active}`);
+    }
+  });
+
+providersCommand
+  .command("login")
+  .description("Save provider API key")
+  .requiredOption("-p, --provider <provider>", "Provider name")
+  .requiredOption("-k, --api-key <apiKey>", "API key")
+  .action((options) => {
+    const config = loadConfig();
+
+    config.providers[options.provider] = {
+      apiKey: options.apiKey,
+    };
+
+    if (!config.activeProvider) {
+      config.activeProvider = options.provider;
+    }
+
+    saveConfig(config);
+
+    console.log(chalk.green(`Logged in provider: ${options.provider}`));
+  });
+
+providersCommand
+  .command("set")
+  .description("Set active provider")
+  .argument("<provider>", "Provider name")
+  .action((provider) => {
+    const config = loadConfig();
+
+    if (!config.providers[provider]) {
+      console.log(chalk.red(`Provider not found: ${provider}`));
+      return;
+    }
+
+    config.activeProvider = provider;
+    saveConfig(config);
+
+    console.log(chalk.green(`Active provider set to: ${provider}`));
+  });
+
+providersCommand
+  .command("logout")
+  .description("Remove provider")
+  .requiredOption("-p, --provider <provider>", "Provider name")
+  .action((options) => {
+    const config = loadConfig();
+
+    delete config.providers[options.provider];
+
+    if (config.activeProvider === options.provider) {
+      config.activeProvider = Object.keys(config.providers)[0];
+    }
+
+    saveConfig(config);
+
+    console.log(chalk.green(`Logged out provider: ${options.provider}`));
+  });

package/src/commands/tools.ts

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { listFiles, readFile, writeFile } from "../tools/tools.js";
+
+export const toolsCommand = new Command("tools")
+  .description("Test local tools");
+
+toolsCommand
+  .command("list")
+  .argument("[dir]", "Directory", ".")
+  .action((dir) => {
+    try {
+      console.log(listFiles(dir));
+    } catch (err) {
+      console.log(chalk.red(err instanceof Error ? err.message : String(err)));
+    }
+  });
+
+toolsCommand
+  .command("read")
+  .argument("<file>", "File path")
+  .action((file) => {
+    try {
+      console.log(readFile(file));
+    } catch (err) {
+      console.log(chalk.red(err instanceof Error ? err.message : String(err)));
+    }
+  });
+
+toolsCommand
+  .command("write")
+  .argument("<file>", "File path")
+  .argument("<content>", "File content")
+  .action((file, content) => {
+    try {
+      console.log(writeFile(file, content));
+    } catch (err) {
+      console.log(chalk.red(err instanceof Error ? err.message : String(err)));
+    }
+  });

package/src/commands/tui.tsx

@@ -0,0 +1,24 @@
+import { Command } from "commander";
+import React from "react";
+import { render } from "ink";
+import { App } from "../tui/App.js";
+import { clearHistory } from "../lib/history.js";
+import { setWorkspace } from "../tools/workspace.js";
+import { clearAgentMemory } from "../lib/agentMemory.js";
+
+export const tuiCommand = new Command("tui")
+  .description("Start TUI mode")
+  .option("--session <name>", "TUI session name", "tui")
+  .option("--clear", "Clear TUI history before starting")
+  .option("-w, --workspace <workspace>", "Workspace path", process.cwd())
+  .option("--direct", "Use direct streaming chat mode by default")
+  .action((options) => {
+    setWorkspace(options.workspace);
+
+    if (options.clear) {
+      clearHistory(options.session);
+      clearAgentMemory(options.session);
+    }
+
+    render(<App sessionName={options.session} direct={options.direct}/>);
+  });