neural-loom 0.2.13 → 0.2.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neural-loom",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "bin": {
     "neural-loom": "./bin/cli.js"
   },

package/src/app/api/context/aider/route.ts

@@ -17,36 +17,51 @@ function maskKey(key: string): string {
   return `${key.slice(0, 6)}...${key.slice(-4)}`;
 }
 
+import { getWorkspaceFileFolders } from "@/lib/workspaceParser";
+
 export async function GET() {
   try {
+    let openaiApiKey = "";
+    let anthropicApiKey = "";
+    let geminiApiKey = "";
+    let model = "claude-3-5-sonnet";
+    let extraFlags = "";
+    let workspaceRoot = "";
+    let scopedDirs: string[] = [];
+
     if (fs.existsSync(configPath)) {
-      const rawData = fs.readFileSync(configPath, "utf8");
-      const config = JSON.parse(rawData);
-      
-      return NextResponse.json({
-        success: true,
-        config: {
-          openaiApiKey: config.openaiApiKey ? maskKey(config.openaiApiKey) : "",
-          anthropicApiKey: config.anthropicApiKey ? maskKey(config.anthropicApiKey) : "",
-          geminiApiKey: config.geminiApiKey ? maskKey(config.geminiApiKey) : "",
-          model: config.model || "claude-3-5-sonnet",
-          extraFlags: config.extraFlags || "",
-          workspaceRoot: config.workspaceRoot || "",
-          scopedDirs: config.scopedDirs || [],
-        },
-      });
+      try {
+        const rawData = fs.readFileSync(configPath, "utf8");
+        const config = JSON.parse(rawData);
+        openaiApiKey = config.openaiApiKey ? maskKey(config.openaiApiKey) : "";
+        anthropicApiKey = config.anthropicApiKey ? maskKey(config.anthropicApiKey) : "";
+        geminiApiKey = config.geminiApiKey ? maskKey(config.geminiApiKey) : "";
+        model = config.model || "claude-3-5-sonnet";
+        extraFlags = config.extraFlags || "";
+        workspaceRoot = config.workspaceRoot || "";
+        scopedDirs = config.scopedDirs || [];
+      } catch (e) {
+        console.error("Failed to parse aider.json:", e);
+      }
     }
 
+    // Resolve workspace folders from the code-workspace file if it exists
+    const rootToScan = workspaceRoot || process.env.ORIGINAL_CWD || process.cwd();
+    const wsFolders = getWorkspaceFileFolders(rootToScan);
+
+    // Merge scopedDirs, filtering out duplicates
+    const mergedScopes = Array.from(new Set([...scopedDirs, ...wsFolders]));
+
     return NextResponse.json({
       success: true,
       config: {
-        openaiApiKey: "",
-        anthropicApiKey: "",
-        geminiApiKey: "",
-        model: "claude-3-5-sonnet",
-        extraFlags: "",
-        workspaceRoot: "",
-        scopedDirs: [],
+        openaiApiKey,
+        anthropicApiKey,
+        geminiApiKey,
+        model,
+        extraFlags,
+        workspaceRoot,
+        scopedDirs: mergedScopes,
       },
     });
   } catch (error) {

package/src/app/api/context/claude/route.ts

@@ -11,30 +11,42 @@ function ensureDir() {
   }
 }
 
+import { getWorkspaceFileFolders } from "@/lib/workspaceParser";
+
 export async function GET() {
   try {
+    let name = "Claude Local";
+    let workspaceRoot = "";
+    let scopedDirs: string[] = [];
+    let extraFlags = "";
+
     if (fs.existsSync(configPath)) {
-      const rawData = fs.readFileSync(configPath, "utf8");
-      const config = JSON.parse(rawData);
-      
-      return NextResponse.json({
-        success: true,
-        config: {
-          name: config.name || "Claude Local",
-          workspaceRoot: config.workspaceRoot || "",
-          scopedDirs: config.scopedDirs || [],
-          extraFlags: config.extraFlags || "",
-        },
-      });
+      try {
+        const rawData = fs.readFileSync(configPath, "utf8");
+        const config = JSON.parse(rawData);
+        name = config.name || "Claude Local";
+        workspaceRoot = config.workspaceRoot || "";
+        scopedDirs = config.scopedDirs || [];
+        extraFlags = config.extraFlags || "";
+      } catch (e) {
+        console.error("Failed to parse claude.json:", e);
+      }
     }
 
+    // Resolve workspace folders from the code-workspace file if it exists
+    const rootToScan = workspaceRoot || process.env.ORIGINAL_CWD || process.cwd();
+    const wsFolders = getWorkspaceFileFolders(rootToScan);
+
+    // Merge scopedDirs, filtering out duplicates
+    const mergedScopes = Array.from(new Set([...scopedDirs, ...wsFolders]));
+
     return NextResponse.json({
       success: true,
       config: {
-        name: "Claude Local",
-        workspaceRoot: "",
-        scopedDirs: [],
-        extraFlags: "",
+        name,
+        workspaceRoot,
+        scopedDirs: mergedScopes,
+        extraFlags,
       },
     });
   } catch (error) {

package/src/app/api/recents/route.ts

@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+import { loadRecents, addRecent } from "@/lib/recents";
+
+export async function GET() {
+  try {
+    const recents = loadRecents();
+    return NextResponse.json({ success: true, recents });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ success: false, error: errorMessage }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { type, path } = body;
+
+    if (!type || !path) {
+      return NextResponse.json({ success: false, error: "Missing type or path" }, { status: 400 });
+    }
+
+    if (type !== "workspace" && type !== "scope") {
+      return NextResponse.json({ success: false, error: "Invalid type. Must be 'workspace' or 'scope'" }, { status: 400 });
+    }
+
+    addRecent(type, path);
+    const recents = loadRecents();
+    return NextResponse.json({ success: true, recents });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ success: false, error: errorMessage }, { status: 500 });
+  }
+}

package/src/app/api/sessions/launch/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from "next/server";
 import { SessionManager } from "@/lib/agents/SessionManager";
+import { addRecent } from "@/lib/recents";
 
 export async function POST(request: Request) {
   try {
@@ -14,6 +15,17 @@ export async function POST(request: Request) {
     const manager = SessionManager.getInstance();
     const session = await manager.createSession(type, name, workspaceRoot, scopedDirs);
 
+    // Save workspace root to recents list
+    if (workspaceRoot) {
+      addRecent("workspace", workspaceRoot);
+    }
+    // Save scoped directories to recents list
+    if (scopedDirs && Array.isArray(scopedDirs)) {
+      for (const dir of scopedDirs) {
+        addRecent("scope", dir);
+      }
+    }
+
     return NextResponse.json({
       success: true,
       session: session.getStatus()

package/src/app/api/sessions/scope/route.ts

@@ -0,0 +1,139 @@
+import { NextResponse } from "next/server";
+import { SessionManager } from "@/lib/agents/SessionManager";
+import { SessionPersister } from "@/lib/agents/SessionPersister";
+import { ContextManager } from "@/lib/agents/ContextManager";
+import { addRecent } from "@/lib/recents";
+import fs from "fs";
+import path from "path";
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { sessionId, path: newPath, action = "add" } = body;
+
+    if (!sessionId || !newPath) {
+      return NextResponse.json({ error: "Missing sessionId or path" }, { status: 400 });
+    }
+
+    const manager = SessionManager.getInstance();
+    const session = manager.getSession(sessionId);
+
+    if (!session) {
+      return NextResponse.json({ error: "Session not found" }, { status: 404 });
+    }
+
+    // Normalize path
+    const resolvedPath = path.resolve(newPath).replace(/\\/g, "/");
+
+    if (action === "add") {
+      if (!fs.existsSync(resolvedPath)) {
+        return NextResponse.json({ error: "Path does not exist on the server" }, { status: 400 });
+      }
+
+      // 1. Add to active session runner
+      if (!session.scopedDirs) {
+        session.scopedDirs = [];
+      }
+      if (!session.scopedDirs.includes(resolvedPath)) {
+        session.scopedDirs.push(resolvedPath);
+        SessionPersister.saveSession(session, true);
+      }
+
+      // 2. Carry over to global configurations for next Launch
+      const configDir = path.join(process.env.ORIGINAL_CWD || process.cwd(), ".ai", "neural-loom");
+      
+      if (session.type === "claude" || session.type === "claude-docker") {
+        const claudeConfigPath = path.join(configDir, "claude.json");
+        if (fs.existsSync(claudeConfigPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(claudeConfigPath, "utf8"));
+            if (!config.scopedDirs) config.scopedDirs = [];
+            if (!config.scopedDirs.includes(resolvedPath)) {
+              config.scopedDirs.push(resolvedPath);
+              fs.writeFileSync(claudeConfigPath, JSON.stringify(config, null, 2), "utf8");
+            }
+          } catch (err) {
+            console.error("Failed to update claude.json with new scoped folder:", err);
+          }
+        }
+      } else if (session.type === "aider" || session.type === "aider-docker") {
+        const aiderConfigPath = path.join(configDir, "aider.json");
+        if (fs.existsSync(aiderConfigPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(aiderConfigPath, "utf8"));
+            if (!config.scopedDirs) config.scopedDirs = [];
+            if (!config.scopedDirs.includes(resolvedPath)) {
+              config.scopedDirs.push(resolvedPath);
+              fs.writeFileSync(aiderConfigPath, JSON.stringify(config, null, 2), "utf8");
+            }
+          } catch (err) {
+            console.error("Failed to update aider.json with new scoped folder:", err);
+          }
+        }
+      }
+
+      // Add to recents
+      addRecent("scope", resolvedPath);
+
+      // Re-compile context & hot-reload in runner
+      const root = session.workspaceRoot || process.env.ORIGINAL_CWD || process.cwd();
+      ContextManager.compileSessionContext(root, session.scopedDirs);
+      if (session.status === "running") {
+        await manager.injectCommand(sessionId, "/ccc");
+      }
+    } else if (action === "remove") {
+      // 1. Remove from active session runner
+      if (session.scopedDirs) {
+        session.scopedDirs = session.scopedDirs.filter(p => p !== resolvedPath);
+        SessionPersister.saveSession(session, true);
+      }
+
+      // 2. Remove from global configuration so it doesn't carry over
+      const configDir = path.join(process.env.ORIGINAL_CWD || process.cwd(), ".ai", "neural-loom");
+      
+      if (session.type === "claude" || session.type === "claude-docker") {
+        const claudeConfigPath = path.join(configDir, "claude.json");
+        if (fs.existsSync(claudeConfigPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(claudeConfigPath, "utf8"));
+            if (config.scopedDirs) {
+              config.scopedDirs = config.scopedDirs.filter((p: string) => p !== resolvedPath);
+              fs.writeFileSync(claudeConfigPath, JSON.stringify(config, null, 2), "utf8");
+            }
+          } catch (err) {
+            console.error("Failed to remove scoped folder from claude.json:", err);
+          }
+        }
+      } else if (session.type === "aider" || session.type === "aider-docker") {
+        const aiderConfigPath = path.join(configDir, "aider.json");
+        if (fs.existsSync(aiderConfigPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(aiderConfigPath, "utf8"));
+            if (config.scopedDirs) {
+              config.scopedDirs = config.scopedDirs.filter((p: string) => p !== resolvedPath);
+              fs.writeFileSync(aiderConfigPath, JSON.stringify(config, null, 2), "utf8");
+            }
+          } catch (err) {
+            console.error("Failed to remove scoped folder from aider.json:", err);
+          }
+        }
+      }
+
+      // Re-compile context & hot-reload in runner
+      const root = session.workspaceRoot || process.env.ORIGINAL_CWD || process.cwd();
+      ContextManager.compileSessionContext(root, session.scopedDirs);
+      if (session.status === "running") {
+        await manager.injectCommand(sessionId, "/ccc");
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      scopedDirs: session.scopedDirs || []
+    });
+
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}

package/src/app/components/AiderWizard.tsx

@@ -36,10 +36,11 @@ export default function AiderWizard({ onClose, onConfirmLaunch, isDocker }: Aide
   const [errorMessage, setErrorMessage] = useState("");
   const [isBrowsingWorkspace, setIsBrowsingWorkspace] = useState(false);
   const [isBrowsingScope, setIsBrowsingScope] = useState(false);
+  const [recents, setRecents] = useState<{ workspaces: string[]; scopes: string[] }>({ workspaces: [], scopes: [] });
 
-  // Load config on mount
+  // Load config and recents on mount
   useEffect(() => {
-    const loadConfig = async () => {
+    const loadConfigAndRecents = async () => {
       try {
         const res = await fetch("/api/context/aider");
         if (res.ok) {
@@ -56,14 +57,22 @@ export default function AiderWizard({ onClose, onConfirmLaunch, isDocker }: Aide
             });
           }
         }
+
+        const recentsRes = await fetch("/api/recents");
+        if (recentsRes.ok) {
+          const rData = await recentsRes.json();
+          if (rData.success && rData.recents) {
+            setRecents(rData.recents);
+          }
+        }
       } catch (err) {
-        console.error("Failed to load Aider configuration:", err);
+        console.error("Failed to load Aider configuration / recents:", err);
       } finally {
         setIsLoading(false);
       }
     };
 
-    loadConfig();
+    loadConfigAndRecents();
   }, []);
 
   const handleSaveAndLaunch = async () => {
@@ -172,6 +181,31 @@ export default function AiderWizard({ onClose, onConfirmLaunch, isDocker }: Aide
                 Browse...
               </button>
             </div>
+            {recents.workspaces.length > 0 && (
+              <div style={{ marginTop: "0.35rem", display: "flex", gap: "0.35rem", flexWrap: "wrap", alignItems: "center" }}>
+                <span style={{ fontSize: "0.65rem", color: "var(--muted)" }}>Recent:</span>
+                {recents.workspaces.map((wsPath) => (
+                  <button
+                    key={wsPath}
+                    type="button"
+                    onClick={() => setConfig({ ...config, workspaceRoot: wsPath })}
+                    style={{
+                      background: "rgba(255,255,255,0.03)",
+                      border: "1px solid var(--border)",
+                      borderRadius: "3px",
+                      color: "var(--muted)",
+                      fontSize: "0.65rem",
+                      padding: "1px 6px",
+                      cursor: "pointer",
+                      fontFamily: "var(--font-mono)"
+                    }}
+                    title={wsPath}
+                  >
+                    {wsPath.split(/[/\\]/).pop() || wsPath}
+                  </button>
+                ))}
+              </div>
+            )}
             <span style={{ fontSize: "0.7rem", color: "var(--muted)", marginTop: "0.25rem" }}>
               Leave blank to default to the current orchestrator directory.
             </span>
@@ -238,6 +272,38 @@ export default function AiderWizard({ onClose, onConfirmLaunch, isDocker }: Aide
                 Add
               </button>
             </div>
+            {recents.scopes.length > 0 && (
+              <div style={{ marginTop: "0.35rem", display: "flex", gap: "0.35rem", flexWrap: "wrap", alignItems: "center" }}>
+                <span style={{ fontSize: "0.65rem", color: "var(--muted)" }}>Recent:</span>
+                {recents.scopes
+                  .filter(scopePath => !config.scopedDirs.includes(scopePath))
+                  .map((scopePath) => (
+                    <button
+                      key={scopePath}
+                      type="button"
+                      onClick={() => {
+                        if (!config.scopedDirs.includes(scopePath)) {
+                          setConfig({ ...config, scopedDirs: [...config.scopedDirs, scopePath] });
+                        }
+                      }}
+                      style={{
+                        background: "rgba(168, 85, 247, 0.05)",
+                        border: "1px solid rgba(168, 85, 247, 0.2)",
+                        borderRadius: "3px",
+                        color: "#c084fc",
+                        fontSize: "0.65rem",
+                        padding: "1px 6px",
+                        cursor: "pointer",
+                        fontFamily: "var(--font-mono)"
+                      }}
+                      title={scopePath}
+                    >
+                      +{scopePath.split(/[/\\]/).pop() || scopePath}
+                    </button>
+                  ))
+                }
+              </div>
+            )}
           </div>
 
           <div style={formGroupStyle}>

package/src/app/components/ClaudeWizard.tsx

@@ -30,10 +30,11 @@ export default function ClaudeWizard({ onClose, onConfirmLaunch, isDocker }: Cla
   const [errorMessage, setErrorMessage] = useState("");
   const [isBrowsingWorkspace, setIsBrowsingWorkspace] = useState(false);
   const [isBrowsingScope, setIsBrowsingScope] = useState(false);
+  const [recents, setRecents] = useState<{ workspaces: string[]; scopes: string[] }>({ workspaces: [], scopes: [] });
 
-  // Load config on mount
+  // Load config and recents on mount
   useEffect(() => {
-    const loadConfig = async () => {
+    const loadConfigAndRecents = async () => {
       try {
         const res = await fetch("/api/context/claude");
         if (res.ok) {
@@ -47,14 +48,22 @@ export default function ClaudeWizard({ onClose, onConfirmLaunch, isDocker }: Cla
             });
           }
         }
+
+        const recentsRes = await fetch("/api/recents");
+        if (recentsRes.ok) {
+          const rData = await recentsRes.json();
+          if (rData.success && rData.recents) {
+            setRecents(rData.recents);
+          }
+        }
       } catch (err) {
-        console.error("Failed to load Claude configuration:", err);
+        console.error("Failed to load Claude configuration / recents:", err);
       } finally {
         setIsLoading(false);
       }
     };
 
-    loadConfig();
+    loadConfigAndRecents();
   }, [isDocker]);
 
   const handleSaveAndLaunch = async () => {
@@ -141,6 +150,31 @@ export default function ClaudeWizard({ onClose, onConfirmLaunch, isDocker }: Cla
                 Browse...
               </button>
             </div>
+            {recents.workspaces.length > 0 && (
+              <div style={{ marginTop: "0.35rem", display: "flex", gap: "0.35rem", flexWrap: "wrap", alignItems: "center" }}>
+                <span style={{ fontSize: "0.65rem", color: "var(--muted)" }}>Recent:</span>
+                {recents.workspaces.map((wsPath) => (
+                  <button
+                    key={wsPath}
+                    type="button"
+                    onClick={() => setConfig({ ...config, workspaceRoot: wsPath })}
+                    style={{
+                      background: "rgba(255,255,255,0.03)",
+                      border: "1px solid var(--border)",
+                      borderRadius: "3px",
+                      color: "var(--muted)",
+                      fontSize: "0.65rem",
+                      padding: "1px 6px",
+                      cursor: "pointer",
+                      fontFamily: "var(--font-mono)"
+                    }}
+                    title={wsPath}
+                  >
+                    {wsPath.split(/[/\\]/).pop() || wsPath}
+                  </button>
+                ))}
+              </div>
+            )}
             <span style={{ fontSize: "0.7rem", color: "var(--muted)", marginTop: "0.25rem" }}>
               The active folder Claude Code will run in. Leave blank to run in the current orchestrator directory.
             </span>
@@ -221,6 +255,38 @@ export default function ClaudeWizard({ onClose, onConfirmLaunch, isDocker }: Cla
                 Add
               </button>
             </div>
+            {recents.scopes.length > 0 && (
+              <div style={{ marginTop: "0.35rem", display: "flex", gap: "0.35rem", flexWrap: "wrap", alignItems: "center" }}>
+                <span style={{ fontSize: "0.65rem", color: "var(--muted)" }}>Recent:</span>
+                {recents.scopes
+                  .filter(scopePath => !config.scopedDirs.includes(scopePath))
+                  .map((scopePath) => (
+                    <button
+                      key={scopePath}
+                      type="button"
+                      onClick={() => {
+                        if (!config.scopedDirs.includes(scopePath)) {
+                          setConfig({ ...config, scopedDirs: [...config.scopedDirs, scopePath] });
+                        }
+                      }}
+                      style={{
+                        background: "rgba(168, 85, 247, 0.05)",
+                        border: "1px solid rgba(168, 85, 247, 0.2)",
+                        borderRadius: "3px",
+                        color: "#c084fc",
+                        fontSize: "0.65rem",
+                        padding: "1px 6px",
+                        cursor: "pointer",
+                        fontFamily: "var(--font-mono)"
+                      }}
+                      title={scopePath}
+                    >
+                      +{scopePath.split(/[/\\]/).pop() || scopePath}
+                    </button>
+                  ))
+                }
+              </div>
+            )}
           </div>
 
           {errorMessage && (