@burdenoff/vibe-agent 1.0.1 → 1.0.3

package/dist/routes/git.js

@@ -1,29 +1,29 @@
-import { v4 as uuidv4 } from 'uuid';
-import { promises as fs, readFileSync } from 'fs';
-import path from 'path';
+import { v4 as uuidv4 } from "uuid";
+import { promises as fs, readFileSync } from "fs";
+import path from "path";
 export const gitRoutes = async (fastify) => {
     // Get all git repositories
-    fastify.get('/', async (_request, _reply) => {
+    fastify.get("/", async (_request, _reply) => {
         const repositories = fastify.db.getAllGitRepositories();
         return { repositories };
     });
     // Get repository by ID
-    fastify.get('/:id', async (request, reply) => {
+    fastify.get("/:id", async (request, reply) => {
         const { id } = request.params;
         const repository = fastify.db.getGitRepository(id);
         if (!repository) {
-            return reply.code(404).send({ error: 'Repository not found' });
+            return reply.code(404).send({ error: "Repository not found" });
         }
         return { repository };
     });
     // Scan directory for git repositories
-    fastify.post('/scan', async (request, reply) => {
+    fastify.post("/scan", async (request, reply) => {
         const { directory, includeSubmodules = true } = request.body;
         try {
             // Validate directory exists
             const stats = await fs.stat(directory);
             if (!stats.isDirectory()) {
-                return reply.code(400).send({ error: 'Path is not a directory' });
+                return reply.code(400).send({ error: "Path is not a directory" });
             }
             const repositories = await scanForGitRepositories(directory, includeSubmodules);
             // Save repositories to database
@@ -39,42 +39,42 @@ export const gitRoutes = async (fastify) => {
                     // Create new repository
                     const newRepo = fastify.db.createGitRepository({
                         id: uuidv4(),
-                        ...repo
+                        ...repo,
                     });
                     savedRepos.push(newRepo);
                 }
             }
             // Emit scan complete event
-            fastify.io.emit('git:scan-complete', {
+            fastify.io.emit("git:scan-complete", {
                 directory,
-                count: savedRepos.length
+                count: savedRepos.length,
             });
             return {
                 repositories: savedRepos,
                 scannedPath: directory,
-                totalFound: savedRepos.length
+                totalFound: savedRepos.length,
             };
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to scan directory',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to scan directory",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Scan remote directory via SSH
-    fastify.post('/scan-remote', async (request, reply) => {
-        const { connectionId, directory, includeSubmodules = true } = request.body;
+    fastify.post("/scan-remote", async (request, reply) => {
+        const { connectionId, directory, includeSubmodules = true, } = request.body;
         try {
             const connectionConfig = fastify.db.getSSHConnection(connectionId);
             if (!connectionConfig) {
-                return reply.code(404).send({ error: 'SSH connection not found' });
+                return reply.code(404).send({ error: "SSH connection not found" });
             }
             // Use SSH to scan remote directory
-            const { Client } = await import('ssh2');
+            const { Client } = await import("ssh2");
             const conn = new Client();
             return new Promise((resolve) => {
-                conn.on('ready', () => {
+                conn.on("ready", () => {
                     // Command to find git repositories
                     const findCommand = includeSubmodules
                         ? `find ${directory} -name ".git" -type d 2>/dev/null | sed 's/\\/.git$//'`
@@ -83,42 +83,42 @@ export const gitRoutes = async (fastify) => {
                         if (err) {
                             conn.end();
                             return resolve(reply.code(500).send({
-                                error: 'Failed to execute remote command',
-                                details: err.message
+                                error: "Failed to execute remote command",
+                                details: err.message,
                             }));
                         }
-                        let output = '';
-                        stream.on('data', (data) => {
+                        let output = "";
+                        stream.on("data", (data) => {
                             output += data.toString();
                         });
-                        stream.on('close', async () => {
+                        stream.on("close", async () => {
                             conn.end();
-                            const paths = output.split('\n').filter(p => p.trim());
+                            const paths = output.split("\n").filter((p) => p.trim());
                             const repositories = [];
                             for (const repoPath of paths) {
                                 const name = path.basename(repoPath);
-                                const parentPath = paths.find(p => p !== repoPath && repoPath.startsWith(p + '/'));
+                                const parentPath = paths.find((p) => p !== repoPath && repoPath.startsWith(p + "/"));
                                 repositories.push({
                                     path: repoPath,
                                     name,
                                     parentPath: parentPath || undefined,
                                     isSubmodule: !!parentPath,
-                                    projectType: await detectProjectType(repoPath, true)
+                                    projectType: await detectProjectType(repoPath, true),
                                 });
                             }
                             resolve({
                                 repositories,
                                 scannedPath: directory,
                                 connectionId,
-                                totalFound: repositories.length
+                                totalFound: repositories.length,
                             });
                         });
                     });
                 });
-                conn.on('error', (err) => {
+                conn.on("error", (err) => {
                     resolve(reply.code(500).send({
-                        error: 'SSH connection failed',
-                        details: err.message
+                        error: "SSH connection failed",
+                        details: err.message,
                     }));
                 });
                 // Connect with appropriate auth
@@ -138,68 +138,67 @@ export const gitRoutes = async (fastify) => {
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to scan remote directory',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to scan remote directory",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Update repository metadata
-    fastify.put('/:id', async (request, reply) => {
+    fastify.put("/:id", async (request, reply) => {
         const { id } = request.params;
         const updates = request.body;
         try {
             const repository = fastify.db.getGitRepository(id);
             if (!repository) {
-                return reply.code(404).send({ error: 'Repository not found' });
+                return reply.code(404).send({ error: "Repository not found" });
             }
             fastify.db.updateGitRepository(id, updates);
             return { success: true };
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to update repository',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to update repository",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Delete repository from tracking
-    fastify.delete('/:id', async (request, reply) => {
+    fastify.delete("/:id", async (request, reply) => {
         const { id } = request.params;
         try {
             const repository = fastify.db.getGitRepository(id);
             if (!repository) {
-                return reply.code(404).send({ error: 'Repository not found' });
+                return reply.code(404).send({ error: "Repository not found" });
             }
             fastify.db.deleteGitRepository(id);
             return { success: true };
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to delete repository',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to delete repository",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
     // Fix repository hierarchy
-    fastify.post('/fix-hierarchy', async (_request, reply) => {
+    fastify.post("/fix-hierarchy", async (_request, reply) => {
         try {
             const repositories = fastify.db.getAllGitRepositories();
             let fixed = 0;
             for (const repo of repositories) {
                 // Check if this repo is inside another repo
-                const parentRepo = repositories.find(r => r.path !== repo.path &&
-                    repo.path.startsWith(r.path + '/'));
+                const parentRepo = repositories.find((r) => r.path !== repo.path && repo.path.startsWith(r.path + "/"));
                 if (parentRepo && repo.parentPath !== parentRepo.path) {
                     fastify.db.updateGitRepository(repo.id, {
                         parentPath: parentRepo.path,
-                        isSubmodule: true
+                        isSubmodule: true,
                     });
                     fixed++;
                 }
                 else if (!parentRepo && (repo.parentPath || repo.isSubmodule)) {
                     fastify.db.updateGitRepository(repo.id, {
                         parentPath: undefined,
-                        isSubmodule: false
+                        isSubmodule: false,
                     });
                     fixed++;
                 }
@@ -207,13 +206,13 @@ export const gitRoutes = async (fastify) => {
             return {
                 success: true,
                 fixed,
-                total: repositories.length
+                total: repositories.length,
             };
         }
         catch (error) {
             return reply.code(500).send({
-                error: 'Failed to fix hierarchy',
-                details: error instanceof Error ? error.message : 'Unknown error'
+                error: "Failed to fix hierarchy",
+                details: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
@@ -224,7 +223,7 @@ async function scanForGitRepositories(directory, includeSubmodules, parentPath)
     try {
         const entries = await fs.readdir(directory, { withFileTypes: true });
         // Check if this directory is a git repository
-        const hasGit = entries.some(e => e.name === '.git' && e.isDirectory());
+        const hasGit = entries.some((e) => e.name === ".git" && e.isDirectory());
         if (hasGit) {
             const repo = {
                 path: directory,
@@ -232,7 +231,7 @@ async function scanForGitRepositories(directory, includeSubmodules, parentPath)
                 parentPath,
                 isSubmodule: !!parentPath,
                 projectType: await detectProjectType(directory),
-                vitePort: await detectVitePort(directory)
+                vitePort: await detectVitePort(directory),
             };
             repositories.push(repo);
             // If not including submodules, return early
@@ -250,14 +249,14 @@ async function scanForGitRepositories(directory, includeSubmodules, parentPath)
         // Recursively scan subdirectories
         for (const entry of entries) {
             if (entry.isDirectory() &&
-                entry.name !== '.git' &&
-                entry.name !== 'node_modules' &&
-                entry.name !== '__pycache__' &&
-                entry.name !== '.venv' &&
-                entry.name !== 'venv' &&
-                entry.name !== 'dist' &&
-                entry.name !== 'build' &&
-                !entry.name.startsWith('.')) {
+                entry.name !== ".git" &&
+                entry.name !== "node_modules" &&
+                entry.name !== "__pycache__" &&
+                entry.name !== ".venv" &&
+                entry.name !== "venv" &&
+                entry.name !== "dist" &&
+                entry.name !== "build" &&
+                !entry.name.startsWith(".")) {
                 const subPath = path.join(directory, entry.name);
                 const subRepos = await scanForGitRepositories(subPath, includeSubmodules, parentPath);
                 repositories.push(...subRepos);
@@ -278,172 +277,187 @@ async function detectProjectType(directory, remote = false) {
     try {
         const entries = await fs.readdir(directory);
         // Node.js project (check for specific frameworks too)
-        if (entries.includes('package.json')) {
+        if (entries.includes("package.json")) {
             // Try to detect specific Node.js frameworks
             try {
-                const packageJson = JSON.parse(await fs.readFile(path.join(directory, 'package.json'), 'utf8'));
-                const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-                if (deps.react || deps['@types/react'])
-                    return 'react';
-                if (deps.vue || deps['@vue/cli'])
-                    return 'vue';
-                if (deps.angular || deps['@angular/core'])
-                    return 'angular';
-                if (deps.next || deps['@types/next'])
-                    return 'nextjs';
-                if (deps.nuxt || deps['@nuxt/core'])
-                    return 'nuxtjs';
-                if (deps.svelte || deps['@sveltejs/kit'])
-                    return 'svelte';
+                const packageJson = JSON.parse(await fs.readFile(path.join(directory, "package.json"), "utf8"));
+                const deps = {
+                    ...packageJson.dependencies,
+                    ...packageJson.devDependencies,
+                };
+                if (deps.react || deps["@types/react"])
+                    return "react";
+                if (deps.vue || deps["@vue/cli"])
+                    return "vue";
+                if (deps.angular || deps["@angular/core"])
+                    return "angular";
+                if (deps.next || deps["@types/next"])
+                    return "nextjs";
+                if (deps.nuxt || deps["@nuxt/core"])
+                    return "nuxtjs";
+                if (deps.svelte || deps["@sveltejs/kit"])
+                    return "svelte";
                 if (deps.express || deps.fastify || deps.koa)
-                    return 'nodejs-backend';
+                    return "nodejs-backend";
                 if (deps.electron)
-                    return 'electron';
+                    return "electron";
                 if (deps.gatsby)
-                    return 'gatsby';
+                    return "gatsby";
                 if (deps.vite)
-                    return 'vite';
+                    return "vite";
             }
             catch {
                 // Fallback to generic nodejs
             }
-            return 'nodejs';
+            return "nodejs";
         }
         // Python project
-        if (entries.includes('setup.py') ||
-            entries.includes('requirements.txt') ||
-            entries.includes('pyproject.toml') ||
-            entries.includes('Pipfile') ||
-            entries.includes('poetry.lock') ||
-            entries.includes('conda.yml') ||
-            entries.includes('environment.yml')) {
+        if (entries.includes("setup.py") ||
+            entries.includes("requirements.txt") ||
+            entries.includes("pyproject.toml") ||
+            entries.includes("Pipfile") ||
+            entries.includes("poetry.lock") ||
+            entries.includes("conda.yml") ||
+            entries.includes("environment.yml")) {
             // Try to detect specific Python frameworks
             try {
-                if (entries.includes('manage.py'))
-                    return 'django';
-                if (entries.includes('app.py') || entries.includes('application.py'))
-                    return 'flask';
-                if (entries.includes('main.py'))
-                    return 'fastapi';
-                if (entries.includes('streamlit_app.py'))
-                    return 'streamlit';
-                if (entries.includes('requirements.txt')) {
-                    const reqs = await fs.readFile(path.join(directory, 'requirements.txt'), 'utf8');
-                    if (reqs.includes('django'))
-                        return 'django';
-                    if (reqs.includes('flask'))
-                        return 'flask';
-                    if (reqs.includes('fastapi'))
-                        return 'fastapi';
-                    if (reqs.includes('streamlit'))
-                        return 'streamlit';
-                    if (reqs.includes('tensorflow') || reqs.includes('pytorch'))
-                        return 'python-ml';
-                    if (reqs.includes('jupyter'))
-                        return 'jupyter';
+                if (entries.includes("manage.py"))
+                    return "django";
+                if (entries.includes("app.py") || entries.includes("application.py"))
+                    return "flask";
+                if (entries.includes("main.py"))
+                    return "fastapi";
+                if (entries.includes("streamlit_app.py"))
+                    return "streamlit";
+                if (entries.includes("requirements.txt")) {
+                    const reqs = await fs.readFile(path.join(directory, "requirements.txt"), "utf8");
+                    if (reqs.includes("django"))
+                        return "django";
+                    if (reqs.includes("flask"))
+                        return "flask";
+                    if (reqs.includes("fastapi"))
+                        return "fastapi";
+                    if (reqs.includes("streamlit"))
+                        return "streamlit";
+                    if (reqs.includes("tensorflow") || reqs.includes("pytorch"))
+                        return "python-ml";
+                    if (reqs.includes("jupyter"))
+                        return "jupyter";
                 }
             }
             catch {
                 // Fallback to generic python
             }
-            return 'python';
+            return "python";
         }
         // Go project
-        if (entries.includes('go.mod') || entries.includes('go.sum')) {
-            return 'go';
+        if (entries.includes("go.mod") || entries.includes("go.sum")) {
+            return "go";
         }
         // Rust project
-        if (entries.includes('Cargo.toml') || entries.includes('Cargo.lock')) {
-            return 'rust';
+        if (entries.includes("Cargo.toml") || entries.includes("Cargo.lock")) {
+            return "rust";
         }
         // Java project
-        if (entries.includes('pom.xml'))
-            return 'maven';
-        if (entries.includes('build.gradle') || entries.includes('build.gradle.kts'))
-            return 'gradle';
-        if (entries.some(e => e.endsWith('.java')))
-            return 'java';
+        if (entries.includes("pom.xml"))
+            return "maven";
+        if (entries.includes("build.gradle") ||
+            entries.includes("build.gradle.kts"))
+            return "gradle";
+        if (entries.some((e) => e.endsWith(".java")))
+            return "java";
         // Ruby project
-        if (entries.includes('Gemfile')) {
+        if (entries.includes("Gemfile")) {
             try {
-                const gemfile = await fs.readFile(path.join(directory, 'Gemfile'), 'utf8');
-                if (gemfile.includes('rails'))
-                    return 'rails';
-                if (gemfile.includes('sinatra'))
-                    return 'sinatra';
+                const gemfile = await fs.readFile(path.join(directory, "Gemfile"), "utf8");
+                if (gemfile.includes("rails"))
+                    return "rails";
+                if (gemfile.includes("sinatra"))
+                    return "sinatra";
             }
             catch {
                 // Fallback
             }
-            return 'ruby';
+            return "ruby";
         }
         // PHP project
-        if (entries.includes('composer.json')) {
+        if (entries.includes("composer.json")) {
             try {
-                const composer = JSON.parse(await fs.readFile(path.join(directory, 'composer.json'), 'utf8'));
-                const deps = { ...composer.require, ...composer['require-dev'] };
-                if (deps.laravel || deps['laravel/framework'])
-                    return 'laravel';
-                if (deps.symfony || deps['symfony/symfony'])
-                    return 'symfony';
-                if (deps.wordpress || entries.includes('wp-config.php'))
-                    return 'wordpress';
+                const composer = JSON.parse(await fs.readFile(path.join(directory, "composer.json"), "utf8"));
+                const deps = { ...composer.require, ...composer["require-dev"] };
+                if (deps.laravel || deps["laravel/framework"])
+                    return "laravel";
+                if (deps.symfony || deps["symfony/symfony"])
+                    return "symfony";
+                if (deps.wordpress || entries.includes("wp-config.php"))
+                    return "wordpress";
             }
             catch {
                 // Fallback
             }
-            return 'php';
+            return "php";
         }
         // .NET project
-        if (entries.some(e => e.endsWith('.csproj') || e.endsWith('.sln') || e.endsWith('.fsproj') || e.endsWith('.vbproj'))) {
-            return 'dotnet';
+        if (entries.some((e) => e.endsWith(".csproj") ||
+            e.endsWith(".sln") ||
+            e.endsWith(".fsproj") ||
+            e.endsWith(".vbproj"))) {
+            return "dotnet";
         }
         // C/C++ project
-        if (entries.includes('CMakeLists.txt') || entries.includes('Makefile') ||
-            entries.some(e => e.endsWith('.c') || e.endsWith('.cpp') || e.endsWith('.h') || e.endsWith('.hpp'))) {
-            return 'cpp';
+        if (entries.includes("CMakeLists.txt") ||
+            entries.includes("Makefile") ||
+            entries.some((e) => e.endsWith(".c") ||
+                e.endsWith(".cpp") ||
+                e.endsWith(".h") ||
+                e.endsWith(".hpp"))) {
+            return "cpp";
         }
         // Swift project
-        if (entries.includes('Package.swift') || entries.some(e => e.endsWith('.xcodeproj') || e.endsWith('.xcworkspace'))) {
-            return 'swift';
+        if (entries.includes("Package.swift") ||
+            entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"))) {
+            return "swift";
         }
         // Kotlin project
-        if (entries.some(e => e.endsWith('.kt') || e.endsWith('.kts'))) {
-            return 'kotlin';
+        if (entries.some((e) => e.endsWith(".kt") || e.endsWith(".kts"))) {
+            return "kotlin";
         }
         // Scala project
-        if (entries.includes('build.sbt') || entries.some(e => e.endsWith('.scala'))) {
-            return 'scala';
+        if (entries.includes("build.sbt") ||
+            entries.some((e) => e.endsWith(".scala"))) {
+            return "scala";
         }
         // R project
-        if (entries.includes('DESCRIPTION') || entries.some(e => e.endsWith('.R') || e.endsWith('.Rmd'))) {
-            return 'r';
+        if (entries.includes("DESCRIPTION") ||
+            entries.some((e) => e.endsWith(".R") || e.endsWith(".Rmd"))) {
+            return "r";
         }
         // Dart/Flutter project
-        if (entries.includes('pubspec.yaml')) {
-            return 'flutter';
+        if (entries.includes("pubspec.yaml")) {
+            return "flutter";
         }
         // Unity project
-        if (entries.includes('ProjectSettings') && entries.includes('Assets')) {
-            return 'unity';
+        if (entries.includes("ProjectSettings") && entries.includes("Assets")) {
+            return "unity";
         }
         // Docker project
-        if (entries.includes('Dockerfile') || entries.includes('docker-compose.yml')) {
-            return 'docker';
+        if (entries.includes("Dockerfile") ||
+            entries.includes("docker-compose.yml")) {
+            return "docker";
         }
         // Terraform project
-        if (entries.some(e => e.endsWith('.tf') || e.endsWith('.tfvars'))) {
-            return 'terraform';
+        if (entries.some((e) => e.endsWith(".tf") || e.endsWith(".tfvars"))) {
+            return "terraform";
         }
         // Documentation/Static sites
-        if (entries.includes('_config.yml'))
-            return 'jekyll';
-        if (entries.includes('mkdocs.yml'))
-            return 'mkdocs';
-        if (entries.includes('docusaurus.config.js'))
-            return 'docusaurus';
-        if (entries.includes('hugo.toml') || entries.includes('config.toml'))
-            return 'hugo';
+        if (entries.includes("_config.yml"))
+            return "jekyll";
+        if (entries.includes("mkdocs.yml"))
+            return "mkdocs";
+        if (entries.includes("docusaurus.config.js"))
+            return "docusaurus";
+        if (entries.includes("hugo.toml") || entries.includes("config.toml"))
+            return "hugo";
     }
     catch {
         // Ignore errors
@@ -453,8 +467,8 @@ async function detectProjectType(directory, remote = false) {
 // Helper function to detect Vite port
 async function detectVitePort(directory) {
     try {
-        const viteConfigPath = path.join(directory, 'vite.config.js');
-        const viteConfigTsPath = path.join(directory, 'vite.config.ts');
+        const viteConfigPath = path.join(directory, "vite.config.js");
+        const viteConfigTsPath = path.join(directory, "vite.config.ts");
         let configPath;
         try {
             await fs.access(viteConfigPath);
@@ -469,7 +483,7 @@ async function detectVitePort(directory) {
                 return undefined;
             }
         }
-        const content = await fs.readFile(configPath, 'utf-8');
+        const content = await fs.readFile(configPath, "utf-8");
         // Look for port configuration
         const portMatch = content.match(/port:\s*(\d+)/);
         if (portMatch) {
@@ -485,7 +499,7 @@ async function detectVitePort(directory) {
 async function shouldSkipDirectory(directory) {
     try {
         // Check for .gitignore
-        const gitignorePath = path.join(directory, '.gitignore');
+        const gitignorePath = path.join(directory, ".gitignore");
         await fs.access(gitignorePath);
         // For now, we'll use a simple heuristic
         // In a real implementation, you'd parse .gitignore properly