orbital-cli-agent 1.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "orbital-cli-agent",
+  "version": "1.0.0",
+  "description": "A CLI based AI Agent",
+  "main": "src/cli/main.js",
+  "type": "module",
+  "bin": {
+    "orbital": "./src/cli/main.js"
+  },
+  "dependencies": {
+    "@ai-sdk/google": "^3.0.86",
+    "@clack/prompts": "^1.5.1",
+    "ai": "^6.0.214",
+    "better-auth": "^1.6.5",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "dotenv": "^17.4.2",
+    "figlet": "^1.11.0",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "open": "^11.0.0",
+    "yocto-spinner": "^1.2.0",
+    "zod": "^4.4.3"
+  },
+  "files": [
+    "src"
+  ]
+}

package/src/cli/ai/google-service.js

@@ -0,0 +1,128 @@
+import { google } from "@ai-sdk/google";
+import { streamText, generateObject } from "ai";
+import { config } from "../../config/google.config.js";
+import chalk from "chalk";
+
+export class AIService {
+  constructor() {
+    if (!config.googleApiKey) {
+      throw new Error("GOOGLE_API_KEY is not set in environment variables");
+    }
+    
+    this.model = google(config.orbitalModel, {
+      apiKey: config.googleApiKey,
+    });
+  }
+
+  /**
+   * Send a message and get streaming response
+   * @param {Array} messages - Array of message objects {role, content}
+   * @param {Function} onChunk - Callback for each text chunk
+   * @param {Object} tools - Optional tools object
+   * @param {Function} onToolCall - Callback for tool calls
+   * @returns {Promise<Object>} Full response with content, tool calls, and usage
+   */
+  async sendMessage(messages, onChunk, tools = undefined, onToolCall = null) {
+    try {
+      const streamConfig = {
+        model: this.model,
+        messages: messages,
+        temperature: config.temperature,
+        maxTokens: config.maxTokens,
+      };
+
+      // Add tools if provided with maxSteps for multi-step tool calling
+      if (tools && Object.keys(tools).length > 0) {
+        streamConfig.tools = tools;
+        streamConfig.maxSteps = 5; // Allow up to 5 tool call steps
+        
+        console.log(chalk.gray(`[DEBUG] Tools enabled: ${Object.keys(tools).join(', ')}`));
+      }
+
+      const result = streamText(streamConfig);
+      
+      let fullResponse = "";
+      
+      // Stream text chunks
+      for await (const chunk of result.textStream) {
+        fullResponse += chunk;
+        if (onChunk) {
+          onChunk(chunk);
+        }
+      }
+
+      // IMPORTANT: Await the result to get access to steps, toolCalls, etc.
+      const fullResult = await result;
+      
+      const toolCalls = [];
+      const toolResults = [];
+      
+      // Collect tool calls from all steps (if they exist)
+      if (fullResult.steps && Array.isArray(fullResult.steps)) {
+        for (const step of fullResult.steps) {
+          if (step.toolCalls && step.toolCalls.length > 0) {
+            for (const toolCall of step.toolCalls) {
+              toolCalls.push(toolCall);
+              if (onToolCall) {
+                onToolCall(toolCall);
+              }
+            }
+          }
+          
+          // Collect tool results
+          if (step.toolResults && step.toolResults.length > 0) {
+            toolResults.push(...step.toolResults);
+          }
+        }
+      }
+
+      return {
+        content: fullResponse,
+        finishReason: fullResult.finishReason,
+        usage: fullResult.usage,
+        toolCalls,
+        toolResults,
+        steps: fullResult.steps,
+      };
+    } catch (error) {
+      console.error(chalk.red("AI Service Error:"), error.message);
+      console.error(chalk.red("Full error:"), error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get a non-streaming response
+   * @param {Array} messages - Array of message objects
+   * @param {Object} tools - Optional tools
+   * @returns {Promise<string>} Response text
+   */
+  async getMessage(messages, tools = undefined) {
+    let fullResponse = "";
+    const result = await this.sendMessage(messages, (chunk) => {
+      fullResponse += chunk;
+    }, tools);
+    return result.content;
+  }
+
+  /**
+   * Generate structured output using a Zod schema
+   * @param {Object} schema - Zod schema
+   * @param {string} prompt - Prompt for generation
+   * @returns {Promise<Object>} Parsed object matching the schema
+   */
+  async generateStructured(schema, prompt) {
+    try {
+      const result = await generateObject({
+        model: this.model,
+        schema: schema,
+        prompt: prompt,
+      });
+      
+      return result.object;
+    } catch (error) {
+      console.error(chalk.red("AI Structured Generation Error:"), error.message);
+      throw error;
+    }
+  }
+}

package/src/cli/api/api-client.js

@@ -0,0 +1,115 @@
+import chalk from "chalk";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const URL = process.env.BETTER_AUTH_URL || "http://localhost:3005";
+
+export async function getUserFromApi(accessToken) {
+  try {
+    const response = await fetch(`${URL}/api/me`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const data = await response.json();
+    return data?.user || null;
+  } catch (error) {
+    console.error(chalk.red("Failed to fetch user session from server:"), error.message);
+    return null;
+  }
+}
+
+export async function getOrCreateConversation(accessToken, conversationId, mode = "chat") {
+  try {
+    const response = await fetch(`${URL}/api/chat/conversations`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+      },
+      body: JSON.stringify({ conversationId, mode }),
+    });
+
+    if (!response.ok) {
+      const errData = await response.json();
+      throw new Error(errData.error || "Failed to get or create conversation");
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error(chalk.red("API Error (getOrCreateConversation):"), error.message);
+    throw error;
+  }
+}
+
+export async function addMessage(accessToken, conversationId, role, content) {
+  try {
+    const response = await fetch(`${URL}/api/chat/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+      },
+      body: JSON.stringify({ conversationId, role, content }),
+    });
+
+    if (!response.ok) {
+      const errData = await response.json();
+      throw new Error(errData.error || "Failed to add message");
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error(chalk.red("API Error (addMessage):"), error.message);
+    throw error;
+  }
+}
+
+export async function getMessages(accessToken, conversationId) {
+  try {
+    const response = await fetch(`${URL}/api/chat/conversations/${conversationId}/messages`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    if (!response.ok) {
+      const errData = await response.json();
+      throw new Error(errData.error || "Failed to get messages");
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error(chalk.red("API Error (getMessages):"), error.message);
+    throw error;
+  }
+}
+
+export async function updateTitle(accessToken, conversationId, title) {
+  try {
+    const response = await fetch(`${URL}/api/chat/conversations/${conversationId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+      },
+      body: JSON.stringify({ title }),
+    });
+
+    if (!response.ok) {
+      const errData = await response.json();
+      throw new Error(errData.error || "Failed to update title");
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error(chalk.red("API Error (updateTitle):"), error.message);
+    throw error;
+  }
+}

package/src/cli/chat/chat-with-ai-agent.js

@@ -0,0 +1,237 @@
+import chalk from "chalk";
+import boxen from "boxen";
+import { text, isCancel, cancel, intro, outro, confirm } from "@clack/prompts";
+import { AIService } from "../ai/google-service.js";
+import { getStoredToken } from "../commands/auth/login.js";
+import { generateApplication } from "../../config/agent.config.js";
+import * as apiClient from "../api/api-client.js";
+import path from "path";
+
+const aiService = new AIService();
+
+function getSmartOutputDir() {
+  if (process.env.ORBIT_OUTPUT_DIR) {
+    return path.resolve(process.env.ORBIT_OUTPUT_DIR);
+  }
+
+  const cwd = process.cwd();
+  const isInsideWorkspace = cwd.includes("CLI AI AGENT") || cwd.includes("cli-ai-agent");
+
+  if (isInsideWorkspace) {
+    const pathParts = cwd.split(path.sep);
+    const index = pathParts.findIndex(part => 
+      part.toLowerCase() === "cli ai agent" || part.toLowerCase() === "cli-ai-agent"
+    );
+    
+    if (index !== -1) {
+      const parentDir = pathParts.slice(0, index).join(path.sep);
+      return path.join(parentDir, "orbit-apps");
+    }
+    
+    return path.join(cwd, "..", "orbit-apps");
+  }
+
+  return cwd;
+}
+
+async function getUserFromToken() {
+  const token = await getStoredToken();
+  
+  if (!token?.access_token) {
+    throw new Error("Not authenticated. Please run 'orbit login' first.");
+  }
+
+  const user = await apiClient.getUserFromApi(token.access_token);
+
+  if (!user) {
+    throw new Error("User not found. Please login again.");
+  }
+
+  console.log(chalk.green(`\n✓ Welcome back, ${user.name}!\n`));
+  return { user, token };
+}
+
+async function initConversation(token, userId, conversationId = null) {
+  const conversation = await apiClient.getOrCreateConversation(
+    token,
+    conversationId,
+    "agent"
+  );
+  
+  const conversationInfo = boxen(
+    `${chalk.bold("Conversation")}: ${conversation.title}\n` +
+    `${chalk.gray("ID:")} ${conversation.id}\n` +
+    `${chalk.gray("Mode:")} ${chalk.magenta("Agent (Code Generator)")}\n` +
+    `${chalk.cyan("Target Directory:")} ${getSmartOutputDir()}`,
+    {
+      padding: 1,
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "round",
+      borderColor: "magenta",
+      title: "🤖 Agent Mode",
+      titleAlignment: "center",
+    }
+  );
+  
+  console.log(conversationInfo);
+  
+  return conversation;
+}
+
+async function saveMessage(token, conversationId, role, content) {
+  return await apiClient.addMessage(token, conversationId, role, content);
+}
+
+async function agentLoop(token, conversation) {
+  const helpBox = boxen(
+    `${chalk.cyan.bold("What can the agent do?")}\n\n` +
+    `${chalk.gray('• Generate complete applications from descriptions')}\n` +
+    `${chalk.gray('• Create all necessary files and folders')}\n` +
+    `${chalk.gray('• Include setup instructions and commands')}\n` +
+    `${chalk.gray('• Generate production-ready code')}\n\n` +
+    `${chalk.yellow.bold("Examples:")}\n` +
+    `${chalk.white('• "Build a todo app with React and Tailwind"')}\n` +
+    `${chalk.white('• "Create a REST API with Express and MongoDB"')}\n` +
+    `${chalk.white('• "Make a weather app using OpenWeatherMap API"')}\n\n` +
+    `${chalk.gray('Type "exit" to end the session')}`,
+    {
+      padding: 1,
+      margin: { bottom: 1 },
+      borderStyle: "round",
+      borderColor: "cyan",
+      title: "💡 Agent Instructions",
+    }
+  );
+  
+  console.log(helpBox);
+
+  while (true) {
+    const userInput = await text({
+      message: chalk.magenta("🤖 What would you like to build?"),
+      placeholder: "Describe your application...",
+      validate(value) {
+        if (!value || value.trim().length === 0) {
+          return "Description cannot be empty";
+        }
+        if (value.trim().length < 10) {
+          return "Please provide more details (at least 10 characters)";
+        }
+      },
+    });
+
+    if (isCancel(userInput)) {
+      console.log(chalk.yellow("\n👋 Agent session cancelled\n"));
+      process.exit(0);
+    }
+
+    if (userInput.toLowerCase() === "exit") {
+      console.log(chalk.yellow("\n👋 Agent session ended\n"));
+      break;
+    }
+
+    const userBox = boxen(chalk.white(userInput), {
+      padding: 1,
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "round",
+      borderColor: "blue",
+      title: "👤 Your Request",
+      titleAlignment: "left",
+    });
+    console.log(userBox);
+
+    // Save user message
+    await saveMessage(token, conversation.id, "user", userInput);
+
+    try {
+      // Generate application using structured output
+      const outputDir = getSmartOutputDir();
+      const result = await generateApplication(
+        userInput,
+        aiService,
+        outputDir
+      );
+
+      if (result && result.success) {
+        // Save successful generation details
+        const responseMessage = `Generated application: ${result.folderName}\n` +
+          `Files created: ${result.files.length}\n` +
+          `Location: ${result.appDir}\n\n` +
+          `Setup commands:\n${result.commands.join('\n')}`;
+        
+        await saveMessage(token, conversation.id, "assistant", responseMessage);
+
+        // Ask if user wants to generate another app
+        const continuePrompt = await confirm({
+          message: chalk.cyan("Would you like to generate another application?"),
+          initialValue: false,
+        });
+
+        if (isCancel(continuePrompt) || !continuePrompt) {
+          console.log(chalk.yellow("\n👋 Great! Check your new application.\n"));
+          break;
+        }
+
+      } else {
+        throw new Error("Generation returned no result");
+      }
+
+    } catch (error) {
+      console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+      
+      await saveMessage(token, conversation.id, "assistant", `Error: ${error.message}`);
+      
+      const retry = await confirm({
+        message: chalk.cyan("Would you like to try again?"),
+        initialValue: true,
+      });
+
+      if (isCancel(retry) || !retry) {
+        break;
+      }
+    }
+  }
+}
+
+export async function startAgentChat(conversationId = null) {
+  try {
+    intro(
+      boxen(
+        chalk.bold.magenta("🤖 Orbit AI - Agent Mode\n\n") + 
+        chalk.gray("Autonomous Application Generator"),
+        {
+          padding: 1,
+          borderStyle: "double",
+          borderColor: "magenta",
+        }
+      )
+    );
+
+    const { user, token } = await getUserFromToken();
+    
+    // Warning about file system access
+    const shouldContinue = await confirm({
+      message: chalk.yellow("⚠️  The agent will create files and folders in the current directory. Continue?"),
+      initialValue: true,
+    });
+
+    if (isCancel(shouldContinue) || !shouldContinue) {
+      cancel(chalk.yellow("Agent mode cancelled"));
+      process.exit(0);
+    }
+    
+    const conversation = await initConversation(token.access_token, user.id, conversationId);
+    await agentLoop(token.access_token, conversation);
+    
+    outro(chalk.green.bold("\n✨ Thanks for using Agent Mode!"));
+    
+  } catch (error) {
+    const errorBox = boxen(chalk.red(`❌ Error: ${error.message}`), {
+      padding: 1,
+      margin: 1,
+      borderStyle: "round",
+      borderColor: "red",
+    });
+    console.log(errorBox);
+    process.exit(1);
+  }
+}