neural-loom 0.1.1

package/src/lib/agents/AiderRunner.ts

@@ -0,0 +1,261 @@
+import fs from "fs";
+import path from "path";
+import type { IPty } from "node-pty";
+import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { SessionPersister } from "./SessionPersister";
+
+function findGitBash(): string | null {
+  const pf = process.env.PROGRAMFILES || "C:\\Program Files";
+  const pf86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+  const local = process.env.LOCALAPPDATA || "";
+
+  const candidates: string[] = [
+    process.env.WINGMAN_BASH_PATH,
+    path.join(pf, "Git", "bin", "bash.exe"),
+    path.join(pf86, "Git", "bin", "bash.exe"),
+    local ? path.join(local, "Programs", "Git", "bin", "bash.exe") : "",
+  ].filter((p): p is string => typeof p === "string" && p !== "");
+
+  return candidates.find(p => fs.existsSync(p)) || null;
+}
+
+export class AiderRunner extends AgentRunner {
+  id: string;
+  name: string;
+  type: 'aider' | 'aider-docker';
+  status: 'idle' | 'running' | 'stopped' = 'idle';
+  createdAt: string;
+  logs: string[] = [];
+
+  private ptyProcess: IPty | null = null;
+  private ptyModule: typeof import("node-pty") | null = null;
+
+  constructor(id: string, type: 'aider' | 'aider-docker', name?: string) {
+    super();
+    this.id = id;
+    this.type = type;
+    this.name = name || (type === 'aider-docker' ? `Aider Docker ${id.substring(0, 8)}` : `Aider Session ${id.substring(0, 8)}`);
+    this.createdAt = new Date().toISOString();
+  }
+
+  private appendLog(line: string) {
+    this.logs.push(line);
+    if (this.logs.length > 5000) {
+      this.logs.shift();
+    }
+    this.parseTokenUsage(line);
+    this.emitOutput(line);
+    SessionPersister.saveSession(this);
+  }
+
+  async start(): Promise<void> {
+    if (this.status === 'running') return;
+
+    this.status = 'running';
+    this.appendLog("\x1b[1;35m==================================================\x1b[0m\r\n");
+    this.appendLog(`\x1b[1;36m       NEURALLOOM AIDER AGENT ROUTE (${this.type.toUpperCase()})    \x1b[0m\r\n`);
+    this.appendLog("\x1b[1;35m==================================================\x1b[0m\r\n");
+
+    const bashPath = findGitBash();
+    if (!bashPath) {
+      this.status = 'stopped';
+      this.appendLog("\x1b[1;31m[System Error] Git Bash not found. Cannot spawn terminal.\x1b[0m\r\n");
+      return;
+    }
+
+    try {
+      if (!this.ptyModule) {
+        this.ptyModule = await import("node-pty");
+      }
+
+      // Load Aider configuration
+      let aiderConfig = {
+        openaiApiKey: "",
+        anthropicApiKey: "",
+        geminiApiKey: "",
+        model: "claude-3-5-sonnet",
+        extraFlags: "",
+      };
+
+      const aiderConfigPath = path.join(process.cwd(), ".ai", "neural-loom", "aider.json");
+      if (fs.existsSync(aiderConfigPath)) {
+        try {
+          aiderConfig = JSON.parse(fs.readFileSync(aiderConfigPath, "utf8"));
+        } catch (err) {
+          console.error("Failed to parse Aider configuration:", err);
+        }
+      }
+
+      // Setup process environment with injected keys
+      const customEnv = {
+        ...process.env,
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor",
+      } as Record<string, string>;
+
+      if (aiderConfig.openaiApiKey) {
+        customEnv.OPENAI_API_KEY = aiderConfig.openaiApiKey;
+      }
+      if (aiderConfig.anthropicApiKey) {
+        customEnv.ANTHROPIC_API_KEY = aiderConfig.anthropicApiKey;
+      }
+      if (aiderConfig.geminiApiKey) {
+        customEnv.GEMINI_API_KEY = aiderConfig.geminiApiKey;
+      }
+
+      const modelFlag = aiderConfig.model ? `--model ${aiderConfig.model}` : "";
+      const extraFlags = aiderConfig.extraFlags || "";
+
+      const targetCwd = (this.workspaceRoot && fs.existsSync(this.workspaceRoot)) 
+        ? this.workspaceRoot 
+        : process.cwd();
+
+      if (this.type === "aider-docker") {
+        this.appendLog("[System] Verifying Docker environment accessibility...\r\n");
+
+        // Check if docker executable exists by spawning `docker -v`
+        const testPty = this.ptyModule.spawn(bashPath, ["-c", "docker --version"], {
+          name: "xterm-256color",
+          cols: 80,
+          rows: 10,
+          cwd: targetCwd,
+        });
+
+        let hasDocker = false;
+        testPty.onData((data) => {
+          if (data.toLowerCase().includes("docker version")) {
+            hasDocker = true;
+          }
+        });
+
+        await new Promise(resolve => setTimeout(resolve, 800));
+        testPty.kill();
+
+        if (!hasDocker) {
+          this.status = 'stopped';
+          this.appendLog("\x1b[1;31m[Dependency Warning] Docker command not recognized in local PATH.\x1b[0m\r\n");
+          this.appendLog("\x1b[1;33mPlease install Docker Desktop and ensure the daemon is running.\x1b[0m\r\n");
+          return;
+        }
+
+        this.appendLog("[System] Spawning Aider container environment...\r\n");
+        const envFlags: string[] = [];
+        if (aiderConfig.openaiApiKey) envFlags.push("-e OPENAI_API_KEY");
+        if (aiderConfig.anthropicApiKey) envFlags.push("-e ANTHROPIC_API_KEY");
+        if (aiderConfig.geminiApiKey) envFlags.push("-e GEMINI_API_KEY");
+        const envFlagsStr = envFlags.join(" ");
+
+        // Volume mounts for primary workspace and each scoped directory
+        const mounts: string[] = [`-v "${targetCwd}:/workspace"`];
+        if (this.scopedDirs && Array.isArray(this.scopedDirs)) {
+          this.scopedDirs.forEach((dir) => {
+            if (fs.existsSync(dir)) {
+              const folderName = path.basename(dir).replace(/[^a-zA-Z0-9-_]/g, "_");
+              mounts.push(`-v "${dir}:/scoped/${folderName}"`);
+            }
+          });
+        }
+        const mountsStr = mounts.join(" ");
+
+        const dockerCmd = `docker run -it --name neural-loom-session-${this.id} --rm ${mountsStr} -w /workspace ${envFlagsStr} paulgauthier/aider ${modelFlag} ${extraFlags}`.trim();
+
+        this.ptyProcess = this.ptyModule.spawn(bashPath, ["-c", dockerCmd], {
+          name: "xterm-256color",
+          cols: 120,
+          rows: 30,
+          cwd: targetCwd,
+          env: customEnv,
+        });
+      } else {
+        this.appendLog("[System] Verifying 'aider' command availability in local PATH...\r\n");
+
+        // Check if aider executable exists by running `aider --version`
+        const testPty = this.ptyModule.spawn(bashPath, ["-c", "aider --version"], {
+          name: "xterm-256color",
+          cols: 80,
+          rows: 10,
+          cwd: targetCwd,
+        });
+
+        let hasAider = false;
+        testPty.onData((data) => {
+          if (data.toLowerCase().includes("aider")) {
+            hasAider = true;
+          }
+        });
+
+        await new Promise(resolve => setTimeout(resolve, 800));
+        testPty.kill();
+
+        if (!hasAider) {
+          this.status = 'stopped';
+          this.appendLog("\x1b[1;31m[Dependency Warning] 'aider' executable not found on local PATH.\x1b[0m\r\n");
+          this.appendLog("\x1b[1;33mPlease install Aider globally via pip:\r\n  pip install aider-chat\x1b[0m\r\n");
+          return;
+        }
+
+        this.appendLog("[System] Spawning local Aider CLI...\r\n");
+        const localCmd = `aider ${modelFlag} ${extraFlags}`.trim();
+
+        this.ptyProcess = this.ptyModule.spawn(bashPath, ["-c", localCmd], {
+          name: "xterm-256color",
+          cols: 120,
+          rows: 30,
+          cwd: targetCwd,
+          env: customEnv,
+        });
+      }
+
+      this.ptyProcess.onData((data: string) => {
+        this.appendLog(data);
+      });
+
+      this.ptyProcess.onExit(({ exitCode, signal }: { exitCode: number; signal?: number }) => {
+        this.status = 'stopped';
+        this.appendLog(`\r\n\x1b[1;31m[System] Aider process exited (code=${exitCode}, signal=${signal}).\x1b[0m\r\n`);
+        this.ptyProcess = null;
+      });
+
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Unknown error";
+      this.status = 'stopped';
+      this.appendLog(`\x1b[1;31m[System Error] Failed to launch Aider: ${errorMessage}\x1b[0m\r\n`);
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.status = 'stopped';
+    if (this.ptyProcess) {
+      try {
+        this.ptyProcess.kill();
+      } catch (err) {
+        console.error("Error killing Aider PTY process:", err);
+      }
+      this.ptyProcess = null;
+    }
+    this.appendLog("\r\n\x1b[1;31m[System] Aider session terminated.\x1b[0m\r\n");
+  }
+
+  async sendInput(text: string, isRaw = false): Promise<void> {
+    if (this.status !== 'running' || !this.ptyProcess) {
+      this.appendLog(`\r\n\x1b[1;31m[Error] Cannot write: Aider process is ${this.status}.\x1b[0m\r\n`);
+      return;
+    }
+
+    this.ptyProcess.write(isRaw ? text : text + "\r");
+  }
+
+  getStatus(): RunnerStatus {
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      status: this.status,
+      createdAt: this.createdAt,
+      logsCount: this.logs.length,
+      workspaceRoot: this.workspaceRoot,
+      scopedDirs: this.scopedDirs,
+      tokenUsage: this.tokenUsage
+    };
+  }
+}

package/src/lib/agents/ClaudeRunner.ts

@@ -0,0 +1,148 @@
+import fs from "fs";
+import path from "path";
+import type { IPty } from "node-pty";
+import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { SessionPersister } from "./SessionPersister";
+
+function findGitBash(): string | null {
+  const pf = process.env.PROGRAMFILES || "C:\\Program Files";
+  const pf86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+  const local = process.env.LOCALAPPDATA || "";
+
+  const candidates: string[] = [
+    process.env.WINGMAN_BASH_PATH,
+    path.join(pf, "Git", "bin", "bash.exe"),
+    path.join(pf86, "Git", "bin", "bash.exe"),
+    local ? path.join(local, "Programs", "Git", "bin", "bash.exe") : "",
+  ].filter((p): p is string => typeof p === "string" && p !== "");
+
+  return candidates.find(p => fs.existsSync(p)) || null;
+}
+
+export class ClaudeRunner extends AgentRunner {
+  id: string;
+  name: string;
+  type: 'mock' | 'claude' = 'claude';
+  status: 'idle' | 'running' | 'stopped' = 'idle';
+  createdAt: string;
+  logs: string[] = [];
+
+  private ptyProcess: IPty | null = null;
+  private ptyModule: typeof import("node-pty") | null = null;
+
+  constructor(id: string, name?: string) {
+    super();
+    this.id = id;
+    this.name = name || `Claude Session ${id.substring(0, 8)}`;
+    this.createdAt = new Date().toISOString();
+  }
+
+  private appendLog(line: string) {
+    this.logs.push(line);
+    if (this.logs.length > 5000) {
+      this.logs.shift();
+    }
+    this.parseTokenUsage(line);
+    this.emitOutput(line);
+    SessionPersister.saveSession(this);
+  }
+
+  async start(): Promise<void> {
+    if (this.status === 'running') return;
+
+    // Detect Git Bash on Windows
+    const bashPath = findGitBash();
+    if (!bashPath) {
+      this.status = 'stopped';
+      this.appendLog("\x1b[1;31m[System Error] Git Bash not found. Please install Git for Windows.\x1b[0m\r\n");
+      return;
+    }
+
+    try {
+      // Dynamic import to prevent bundler SSR/Turbopack errors on server start
+      if (!this.ptyModule) {
+        this.ptyModule = await import("node-pty");
+      }
+
+      this.status = 'running';
+      this.appendLog("\x1b[1;35m==================================================\x1b[0m\r\n");
+      this.appendLog("\x1b[1;36m       NEURALLOOM ACTIVE CLAUDE TERMINAL ROUTE     \x1b[0m\r\n");
+      this.appendLog("\x1b[1;35m==================================================\x1b[0m\r\n");
+      this.appendLog(`[System] Spawning Claude Code CLI process using Git Bash...\r\n`);
+
+      const targetCwd = (this.workspaceRoot && fs.existsSync(this.workspaceRoot)) 
+        ? this.workspaceRoot 
+        : process.cwd();
+
+      // Spawn bash and run 'claude' command
+      this.ptyProcess = this.ptyModule.spawn(bashPath, ["-c", "claude --agents-md"], {
+        name: "xterm-256color",
+        cols: 120,
+        rows: 30,
+        cwd: targetCwd,
+        env: {
+          ...process.env,
+          TERM: "xterm-256color",
+          COLORTERM: "truecolor",
+          // Inject custom path just in case child processes need Visual Studio Node
+          PATH: "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\MSBuild\\Microsoft\\VisualStudio\\NodeJs;" + process.env.PATH
+        },
+      });
+
+      // Capture output
+      this.ptyProcess.onData((data: string) => {
+        this.appendLog(data);
+      });
+
+      // Capture process exit
+      this.ptyProcess.onExit(({ exitCode, signal }: { exitCode: number; signal?: number }) => {
+        this.status = 'stopped';
+        this.appendLog(`\r\n\x1b[1;31m[System] Claude Code PTY process exited (code=${exitCode}, signal=${signal}).\x1b[0m\r\n`);
+        this.ptyProcess = null;
+      });
+
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Unknown error";
+      this.status = 'stopped';
+      this.appendLog(`\x1b[1;31m[System Error] Failed to initialize node-pty runner: ${errorMessage}\x1b[0m\r\n`);
+      console.error("Failed to start Claude PTY runner:", err);
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.status = 'stopped';
+    if (this.ptyProcess) {
+      try {
+        this.ptyProcess.kill();
+      } catch (err) {
+        console.error("Error killing PTY process:", err);
+      }
+      this.ptyProcess = null;
+    }
+    this.appendLog("\r\n\x1b[1;31m[System] Terminal bridge terminated.\x1b[0m\r\n");
+  }
+
+  async sendInput(text: string, isRaw = false): Promise<void> {
+    if (this.status !== 'running' || !this.ptyProcess) {
+      this.appendLog(`\r\n\x1b[1;31m[Error] Cannot write: session process is ${this.status}.\x1b[0m\r\n`);
+      return;
+    }
+
+    // PTY processes require carriage return (\r) to execute the command line
+    this.ptyProcess.write(isRaw ? text : text + "\r");
+  }
+
+  getStatus(): RunnerStatus {
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      status: this.status,
+      createdAt: this.createdAt,
+      logsCount: this.logs.length,
+      workspaceRoot: this.workspaceRoot,
+      scopedDirs: this.scopedDirs,
+      tokenUsage: this.tokenUsage
+    };
+  }
+}

package/src/lib/agents/ContextManager.ts

@@ -0,0 +1,142 @@
+import fs from "fs";
+import path from "path";
+
+export class ContextManager {
+  private static workspaceRoot = process.cwd();
+
+  private static ensureDirs(root: string) {
+    const aiDir = path.join(root, ".ai", "neural-loom");
+    if (!fs.existsSync(aiDir)) {
+      fs.mkdirSync(aiDir, { recursive: true });
+    }
+
+    const commandDir = path.join(root, ".claude", "commands");
+    if (!fs.existsSync(commandDir)) {
+      fs.mkdirSync(commandDir, { recursive: true });
+    }
+  }
+
+  public static initializeStaging(root: string = process.cwd()) {
+    this.ensureDirs(root);
+
+    // Create /ccp.md custom slash command file
+    const ccpPath = path.join(root, ".claude", "commands", "ccp.md");
+    if (!fs.existsSync(ccpPath)) {
+      fs.writeFileSync(
+        ccpPath,
+        "Read the prompt from .ai/neural-loom/cprompt.md and execute it. This is a staged prompt from the NeuralLoom UI. Treat the contents as user instructions.\n"
+      );
+    }
+
+    // Create /ccc.md custom slash command file
+    const cccPath = path.join(root, ".claude", "commands", "ccc.md");
+    if (!fs.existsSync(cccPath)) {
+      fs.writeFileSync(
+        cccPath,
+        "Read the context from .ai/neural-loom/ccontext.md. This is persistent context from the NeuralLoom UI. Absorb it as background information for this session. Acknowledge briefly what you received.\n"
+      );
+    }
+  }
+
+  public static updatePrompt(promptText: string, root: string = process.cwd()) {
+    this.ensureDirs(root);
+    const promptFile = path.join(root, ".ai", "neural-loom", "cprompt.md");
+    fs.writeFileSync(promptFile, promptText);
+  }
+
+  public static updateContext(contextText: string, root: string = process.cwd()) {
+    this.ensureDirs(root);
+    const contextFile = path.join(root, ".ai", "neural-loom", "ccontext.md");
+    fs.writeFileSync(contextFile, contextText);
+  }
+
+  public static updateRules(rulesText: string, root: string = process.cwd()) {
+    this.ensureDirs(root);
+    const agentsMdPath = path.join(root, "AGENTS.md");
+    fs.writeFileSync(agentsMdPath, rulesText, "utf8");
+  }
+
+  public static loadPrompt(root: string = process.cwd()): string {
+    const promptFile = path.join(root, ".ai", "neural-loom", "cprompt.md");
+    return fs.existsSync(promptFile) ? fs.readFileSync(promptFile, "utf8") : "";
+  }
+
+  public static loadRules(root: string = process.cwd()): string {
+    const agentsMdPath = path.join(root, "AGENTS.md");
+    return fs.existsSync(agentsMdPath) ? fs.readFileSync(agentsMdPath, "utf8") : "";
+  }
+
+  public static compileGlobalRules() {
+    this.compileSessionContext();
+  }
+
+  public static compileSessionContext(root: string = process.cwd(), scopedDirs?: string[]) {
+    this.ensureDirs(root);
+    this.initializeStaging(root);
+    
+    // Check if AGENTS.md rules template exists
+    const agentsMdPath = path.join(root, "AGENTS.md");
+    let agentsRules = "";
+    if (fs.existsSync(agentsMdPath)) {
+      agentsRules = fs.readFileSync(agentsMdPath, "utf8");
+    } else {
+      // Try fallback from global
+      const fallbackPath = path.join(this.workspaceRoot, "AGENTS.md");
+      if (fs.existsSync(fallbackPath)) {
+        agentsRules = fs.readFileSync(fallbackPath, "utf8");
+      }
+    }
+
+    // Generate maps
+    let maps = `## Workspace Root Map (${root}):\n${this.generateProjectMapFor(root)}`;
+
+    if (scopedDirs && Array.isArray(scopedDirs)) {
+      scopedDirs.forEach((dir) => {
+        if (fs.existsSync(dir)) {
+          maps += `\n\n## Scoped Directory Map (${dir}):\n${this.generateProjectMapFor(dir)}`;
+        }
+      });
+    }
+
+    // Combine rules and folder map
+    const compiledContext = `# System Rules & Guidelines\n\n${agentsRules}\n\n# Project File Hierarchy Map\n\n${maps}`;
+    this.updateContext(compiledContext, root);
+
+    // Write a default empty prompt staging file if missing
+    const promptFile = path.join(root, ".ai", "neural-loom", "cprompt.md");
+    if (!fs.existsSync(promptFile)) {
+      fs.writeFileSync(promptFile, "Hello! Please review the project context (/ccc) and check for any tasks to execute.");
+    }
+  }
+
+  private static generateProjectMapFor(targetDir: string): string {
+    try {
+      const walk = (dir: string, depth = 0): string => {
+        if (depth > 2) return ""; // Keep map depth concise to fit tokens
+        let result = "";
+        const files = fs.readdirSync(dir, { withFileTypes: true });
+        for (const file of files) {
+          if (
+            file.name.startsWith(".") ||
+            file.name === "node_modules" ||
+            file.name === "out" ||
+            file.name === ".next"
+          ) {
+            continue;
+          }
+          const indent = "  ".repeat(depth);
+          if (file.isDirectory()) {
+            result += `${indent}- [Dir] ${file.name}/\n`;
+            result += walk(path.join(dir, file.name), depth + 1);
+          } else {
+            result += `${indent}- [File] ${file.name}\n`;
+          }
+        }
+        return result;
+      };
+      return walk(targetDir);
+    } catch (err) {
+      return "Error generating project map: " + (err instanceof Error ? err.message : String(err));
+    }
+  }
+}