@bharatpanigrahi/onw-cli 1.0.1

package/src/config/agent.config.js

@@ -0,0 +1,163 @@
+import { promises as fs } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { generateObject } from "ai";
+import { z } from "zod";
+
+const ApplicationSchema = z.object({
+  folderName: z.string().describe("Kebab-Case folder name for the application"),
+  description: z.string().describe("Brief description of what was created"),
+  files: z.array(
+    z
+      .object({
+        path: z.string().describe("Relative file path (e.g src.App.jsx)"),
+        content: z.string().describe("Complete File content"),
+      })
+      .describe("All files needed for the application"),
+  ),
+  setupCommands: z.array(
+    z
+      .string()
+      .describe(
+        "Bash commands to setup and run (e.g: npm install, npm run dev)",
+      ),
+  ),
+  dependecies: z.record(z.string(), z.string()).default({}),
+});
+
+function printSystem(message) {
+  console.log(message);
+}
+
+function displayFileTree(files, folderName) {
+  printSystem(chalk.cyan("\n📂 Project Structure: "));
+  printSystem(chalk.white(`${folderName}/`));
+
+  const filesByDir = {};
+  files.forEach((file) => {
+    const parts = file.path.split("/");
+    const dir = parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+
+    if (!filesByDir[dir]) {
+      filesByDir[dir] = [];
+    }
+
+    filesByDir[dir].push(parts[parts.length - 1]);
+  });
+
+  Object.keys(filesByDir)
+    .sort()
+    .forEach((dir) => {
+      if (dir) {
+        printSystem(chalk.white(`├──${dir}/`));
+        filesByDir[dir].forEach((file) => {
+          printSystem(chalk.white(`│  └──${file}`));
+        });
+      } else {
+        filesByDir[dir].forEach((file) => {
+          printSystem(chalk.white(`├──${file}`));
+        });
+      }
+    });
+}
+
+async function createApplicationFiles(baseDir, folderName, files) {
+  const appDir = path.join(baseDir, folderName);
+  await fs.mkdir(appDir, { recursive: true });
+
+  printSystem(chalk.cyan("\n📁 Created directory: ${folderName}"));
+
+  for (const file of files) {
+    const filePath = path.join(appDir, file.path);
+    const fileDir = path.dirname(filePath);
+
+    await fs.mkdir(fileDir, { recursive: true });
+    await fs.writeFile(filePath, file.content, "utf-8");
+    printSystem(chalk.green(`  ✔️ ${file.path}`));
+  }
+  return appDir;
+}
+
+export async function generateApplication(
+  description,
+  aiService,
+  cwd = process.cwd(),
+) {
+  try {
+    printSystem(chalk.cyan("🤖 Claude is generating your application..."));
+    printSystem(chalk.gray(`Request: ${description}\n`));
+
+    printSystem(chalk.magenta("Agent Response: \n"));
+
+    const { object: application } = await generateObject({
+      model: aiService.model,
+      schema: ApplicationSchema,
+      prompt: `Create a complete, production-ready application for: ${description}
+
+      CRITICAL REQUIREMENTS:
+      1. Generate ALL files needed for the application to run
+      2. Include package.json with ALL dependencies and correct versions
+      3. Include README.md with setup instructions
+      4. Include configuration files (.gitignore, etc.)
+      5. Write clean, well-commented, production-ready code
+      6. Include error handling and input validation
+      7. Use modern JavaScript/TypeScript best practices
+      8. Make sure all imports and paths are correct
+      9. NO PLACEHOLDERS - everything must be complete and working
+
+      Provide:
+      - A meaningful kebab-case folder name
+      - All necessary files with complete content
+      - Setup commands (cd folder, npm install, npm run dev, etc.)
+      - All dependencies with versions
+      `,
+    });
+
+    printSystem(chalk.green(`\n Generated: ${application.folderName} \n`));
+    printSystem(chalk.gray(`Description: ${application.description} \n`));
+
+    if (application.files.length === 0) {
+      throw new Error("No files were generated by the agent.");
+    }
+
+    displayFileTree(application.files, application.folderName);
+
+    printSystem(chalk.cyan("\n📃 Creating files...\n"));
+
+    const appDir = await createApplicationFiles(
+      cwd,
+      application.folderName,
+      application.files,
+    );
+
+    printSystem(chalk.cyan(`📁 Location: ${chalk.bold(appDir)}\n`));
+
+    if (application.setupCommands.length > 0) {
+      printSystem(chalk.cyan("Next Steps:\n"));
+      printSystem(chalk.white("```bash"));
+
+      application.setupCommands.forEach((cmd) => {
+        printSystem(chalk.white(cmd));
+      });
+
+      printSystem(chalk.white("```\n"));
+
+      return {
+        folderName: application.folderName,
+        appDir,
+        files: application.files.map((f) => f.path),
+        commands: application.setupCommands,
+        success: true,
+      };
+    }
+  } catch (error) {
+    printSystem(
+      chalk.red(`\n❌ Error generating application: ${error?.message}\n`),
+    );
+    if (error?.stack) {
+      printSystem(chalk.dim(error.stack + "\n"));
+    }
+
+    throw error;
+  }
+}

package/src/config/google.config.js

@@ -0,0 +1,7 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+export const config = {
+  googleApiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
+  model: process.env.CLAUDE_MODEL || "gemini-2.5-flash",
+};

package/src/config/tool.config.js

@@ -0,0 +1,105 @@
+import { google } from "@ai-sdk/google";
+import chalk from "chalk";
+
+export const avaiableTools = [
+  {
+    id: "google_search",
+    name: "Google Search",
+    description: "Search the web for up-to-date information.",
+    getTool: () => google.tools.googleSearch({}),
+    enabled: false,
+  },
+  {
+    id: "code_execution",
+    name: "Code Execution",
+    description:
+      "Generate and execute python code to perform calculations, solve problems, or provide accurate information.",
+    getTool: () => google.tools.codeExecution({}),
+    enabled: false,
+  },
+  {
+    id: "url_context",
+    name: "URL Context",
+    description: "Fetch and provide context from a given URL.",
+    getTool: () => google.tools.urlContext({}),
+    enabled: false,
+  },
+];
+
+export const getEnabledTools = () => {
+  const tools = {};
+
+  try {
+    for (const toolConfig of avaiableTools) {
+      if (toolConfig.enabled) {
+        tools[toolConfig.id] = toolConfig.getTool();
+      }
+    }
+
+    // DEBUG logging to verify which tools are enabled
+    if (Object.keys(tools).length > 0) {
+      console.log(
+        chalk.gray(`[DEBUG] Enabled tools: ${Object.keys(tools).join(", ")}`),
+      );
+    } else {
+      console.log(chalk.gray("[DEBUG] No tools enabled"));
+    }
+
+    return tools;
+  } catch (error) {
+    console.error(
+      chalk.red("[ERROR] Failed to initialize tools: ", error?.message),
+    );
+    console.error(
+      chalk.yellow("Make sure you have @ai-sdk/google version 2.0+ installed"),
+    );
+    console.error(chalk.yellow("Run: npm install @ai-sdk/google@latest"));
+    return undefined;
+  }
+};
+
+export function toggleTool(toolId) {
+  const tool = avaiableTools.find((t) => t.id === toolId);
+  if (tool) {
+    tool.enabled = !tool.enabled;
+    console.log(
+      chalk.gray(`[DEBUG] Tool ${toolId} toggled to ${tool.enabled}`),
+    );
+    return tool.enabled;
+  }
+  console.log(chalk.red(`[DEBUG] Tool ${toolId} not found`));
+  return false;
+}
+
+export const enableTools = (toolIds) => {
+  console.log(chalk.gray(`[DEBUG] enableTools called with ${toolIds}`));
+
+  avaiableTools.forEach((tool) => {
+    const wasEnabled = tool.enabled;
+    tool.enabled = toolIds.includes(tool.id);
+
+    if (tool.enabled !== wasEnabled) {
+      console.log(
+        chalk.gray(`[DEBUG] ${tool.id} : ${wasEnabled} -> ${tool.enabled}`),
+      );
+    }
+
+    const enableCount = avaiableTools.filter((t) => t.enabled).length;
+    console.log(
+      chalk.gray(
+        `[DEBUG] Total tools enabled: ${enableCount}/${avaiableTools.length}`,
+      ),
+    );
+  });
+};
+
+export function getEnabledToolNames() {
+  const names = avaiableTools.filter((t) => t.enabled).map((t) => t.name);
+  console.log(chalk.gray("[DEBUG] getEnabledToolNames returning: "), names);
+  return names;
+}
+
+export function resetTools() {
+  avaiableTools.forEach((tool) => (tool.enabled = false));
+  console.log(chalk.gray("[DEBUG] All tools have been reset (disabled)"));
+}

package/src/index.js

@@ -0,0 +1,36 @@
+import express from "express";
+import cors from "cors";
+import { toNodeHandler } from "better-auth/node";
+import dotenv from "dotenv";
+import { auth } from "./lib/auth.js";
+
+dotenv.config();
+const app = express();
+
+app.use(
+  cors({
+    origin: process.env.CORS_ORIGIN,
+    methods: ["GET", "POST", "PUT", "DELETE"],
+    credentials: true,
+    exposedHeaders: ["set-cookie"],
+  }),
+);
+
+app.all("/api/auth/*splat", toNodeHandler(auth));
+
+app.use(express.json());
+
+const PORT = process.env.PORT || 3000;
+
+app.get("/", (req, res) => {
+  res.send("Hello World!");
+});
+
+app.get("/device", async (req, res) => {
+  const { user_code } = req.query;
+  res.redirect(`${process.env.CORS_ORIGIN}/device?user_code=${user_code}`);
+});
+
+app.listen(PORT, () => {
+  console.log(`Server is running on port ${PORT}`);
+});

package/src/lib/auth.js

@@ -0,0 +1,34 @@
+import { betterAuth } from "better-auth";
+import { prismaAdapter } from "better-auth/adapters/prisma";
+import { deviceAuthorization } from "better-auth/plugins";
+import prisma from "./db.js";
+
+const crossSiteCookieAttributes = {
+  sameSite: "none",
+  secure: true,
+};
+
+export const auth = betterAuth({
+  database: prismaAdapter(prisma, {
+    provider: "postgresql",
+  }),
+  baseURL: process.env.BASE_URL,
+  trustedOrigins: [process.env.CORS_ORIGIN],
+  basePath: "/api/auth",
+  socialProviders: {
+    github: {
+      clientId: process.env.GITHUB_CLIENT_ID,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET,
+    },
+  },
+  advanced: {
+    useSecureCookies: true,
+    defaultCookieAttributes: crossSiteCookieAttributes,
+  },
+  plugins: [
+    deviceAuthorization({
+      expiresIn: "30m",
+      interval: "5s",
+    }),
+  ],
+});

package/src/lib/db.js

@@ -0,0 +1,8 @@
+import { PrismaClient } from "@prisma/client";
+
+const globalForPrisma = global;
+
+const prisma = globalForPrisma.prisma ?? new PrismaClient();
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+
+export default prisma;

package/src/lib/token.js

@@ -0,0 +1,85 @@
+import chalk from "chalk";
+import fs from "node:fs/promises";
+import { CONFIG_DIR, TOKEN_FILE } from "../cli/commands/auth/login.js";
+
+export async function getStoredToken() {
+  try {
+    const data = await fs.readFile(TOKEN_FILE, "utf-8");
+    const token = JSON.parse(data);
+    return token;
+  } catch (error) {
+    // File doesn't exist or can't be read
+    return null;
+  }
+}
+
+export async function storeToken(token) {
+  try {
+    // Ensure the config directory exists
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+
+    // store token with metadata
+
+    const tokenData = {
+      access_token: token.access_token,
+      refresh_token: token.refresh_token,
+      token_type: token.token_type || "Bearer",
+      scope: token.scope,
+      expires_at: token.expires_in
+        ? new Date(Date.now() + token.expires_in * 1000).toISOString()
+        : null,
+      created_at: new Date().toISOString(),
+    };
+
+    await fs.writeFile(TOKEN_FILE, JSON.stringify(tokenData, null, 2), "utf-8");
+    return true;
+  } catch (error) {
+    console.error(chalk.red("Failed to store token: "), error?.message);
+    return false;
+  }
+}
+
+export async function clearStoredToken() {
+  try {
+    await fs.unlink(TOKEN_FILE);
+    return true;
+  } catch (error) {
+    // File doesn't exist or can't be deleted
+    return false;
+  }
+}
+
+export async function isTokenExpired() {
+  const token = await getStoredToken();
+  if (!token || !token.expires_at) {
+    return true;
+  }
+
+  const expiresAt = new Date(token.expires_at);
+  const now = new Date();
+
+  return expiresAt.getTime() - now.getTime() < 5 * 60 * 1000;
+}
+
+export async function requireAuth() {
+  const token = await getStoredToken();
+
+  if (!token) {
+    console.log(
+      chalk.red(
+        '❌ Not authenticated. Please run "claude-cli login" to authenticate.',
+      ),
+    );
+    process.exit(1);
+  }
+
+  if (await isTokenExpired()) {
+    console.log(
+      chalk.yellow("⚠️ Your session has expired. Please log in again."),
+    );
+    console.log(chalk.gray("   Run: claude login"));
+    process.exit(1);
+  }
+
+  return token;
+}

package/src/service/chat.service.js

@@ -0,0 +1,104 @@
+import prisma from "../lib/db.js";
+
+export class ChatService {
+  async createConversation(userId, mode = "chat", title = null) {
+    const conversation = await prisma.conversation.create({
+      data: {
+        title: title || `New ${mode} conversation`,
+        mode,
+        user: {
+          connect: { id: userId },
+        },
+      },
+    });
+    return conversation;
+  }
+
+  async getOrCreateConversations(userId, conversationId = null, mode = "chat") {
+    if (conversationId) {
+      const conversation = await prisma.conversation.findFirst({
+        where: {
+          id: conversationId,
+          userId,
+        },
+        include: {
+          messages: {
+            orderBy: {
+              createdAt: "asc",
+            },
+          },
+        },
+      });
+      if (conversation) return conversation;
+    }
+    return await this.createConversation(userId, mode);
+  }
+
+  async addMessage(conversationId, role, content) {
+    const contentStr =
+      typeof content === "string" ? content : JSON.stringify(content);
+    const message = await prisma.message.create({
+      data: {
+        role,
+        content: contentStr,
+        conversation: {
+          connect: { id: conversationId },
+        },
+      },
+    });
+    return message;
+  }
+
+  parseContent(content) {
+    try {
+      return JSON.parse(content);
+    } catch {
+      return content;
+    }
+  }
+
+  async getMessages(conversationId) {
+    const messages = await prisma.message.findMany({
+      where: { conversationId },
+      orderBy: { createdAt: "asc" },
+    });
+    return messages.map((msg) => ({
+      ...msg,
+      content: this.parseContent(msg.content),
+    }));
+  }
+
+  async getConversations(userId) {
+    const conversations = await prisma.conversation.findMany({
+      where: { userId },
+      orderBy: { updatedAt: "desc" },
+      include: {
+        messages: {
+          take: 1,
+          orderBy: { createdAt: "desc" },
+        },
+      },
+    });
+    return conversations;
+  }
+
+  async deleteConversation(conversationId, userId) {
+    return await prisma.conversation.delete({
+      where: { id: conversationId, userId },
+    });
+  }
+
+  async updateTitle(conversationId, title) {
+    return await prisma.conversation.update({
+      where: { id: conversationId },
+      data: { title },
+    });
+  }
+
+  formatMessagesForAI(messages) {
+    return messages.map((msg) => ({
+      role: msg.role,
+      content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+    }));
+  }
+}