letmecook 0.0.21 → 0.0.23

package/src/flows/add-repos.ts

@@ -6,7 +6,6 @@ import { writeAgentsMd } from "../agents-md";
 import { recordRepoHistory } from "../repo-history";
 import { showAddReposPrompt } from "../ui/add-repos";
 import { runCommands, hideCommandRunner, type CommandTask } from "../ui/common/command-runner";
-import { ensureReferenceRepo, linkReferenceRepo, ensureReferencesDir } from "../reference-repo";
 import { rm } from "node:fs/promises";
 
 export interface AddReposParams {
@@ -20,10 +19,7 @@ export interface AddReposResult {
 }
 
 function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTask[] {
-  // Only create command tasks for non-reference repos
-  const regularRepos = repos.filter((repo) => !repo.reference);
-
-  return regularRepos.map((repo) => {
+  return repos.map((repo) => {
     const url = `https://github.com/${repo.owner}/${repo.name}.git`;
     const targetDir = join(sessionPath, repo.dir);
     const args = repo.branch
@@ -49,34 +45,6 @@ function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTas
   });
 }
 
-async function setupReferenceRepos(
-  repos: RepoSpec[],
-  sessionPath: string,
-): Promise<{ successful: RepoSpec[]; failed: Array<{ repo: RepoSpec; error: string }> }> {
-  const referenceRepos = repos.filter((repo) => repo.reference);
-  const successful: RepoSpec[] = [];
-  const failed: Array<{ repo: RepoSpec; error: string }> = [];
-
-  if (referenceRepos.length === 0) {
-    return { successful, failed };
-  }
-
-  await ensureReferencesDir();
-
-  for (const repo of referenceRepos) {
-    try {
-      await ensureReferenceRepo(repo);
-      await linkReferenceRepo(repo, sessionPath);
-      successful.push(repo);
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      failed.push({ repo, error: errorMsg });
-    }
-  }
-
-  return { successful, failed };
-}
-
 export async function addReposFlow(params: AddReposParams): Promise<AddReposResult> {
   const { renderer, session } = params;
 
@@ -87,102 +55,70 @@ export async function addReposFlow(params: AddReposParams): Promise<AddReposResu
     const newRepos = addResult.repos.filter((r) => !existingSpecs.has(r.spec));
 
     if (newRepos.length > 0) {
-      // Setup reference repos first (symlinks from cache)
-      const { successful: successfulRefs, failed: failedRefs } = await setupReferenceRepos(
-        newRepos,
-        session.path,
-      );
-
-      // Report reference repo failures
-      if (failedRefs.length > 0) {
-        console.error(`\n⚠️  ${failedRefs.length} reference repo(s) failed:`);
-        failedRefs.forEach(({ repo, error }) => {
-          console.error(`  ✗ ${repo.owner}/${repo.name}: ${error}`);
-        });
-      }
-
-      // Clone regular repos
       const tasks = reposToCommandTasks(newRepos, session.path);
-      let results: Awaited<ReturnType<typeof runCommands>> = [];
-
-      if (tasks.length > 0) {
-        results = await runCommands(renderer, {
-          title: "Adding repositories",
-          tasks,
-          showOutput: true,
-          outputLines: 5,
-          allowAbort: true,
-          allowSkip: tasks.length > 1,
-          allowBackground: true,
-          sessionName: session.name,
-        });
 
-        // Handle aborted operation - return without changes
-        const wasAborted = results.some((r) => r.outcome === "aborted");
-        if (wasAborted) {
-          hideCommandRunner(renderer);
-          // Clean up any partially cloned repos (non-reference only)
-          const regularRepos = newRepos.filter((r) => !r.reference);
-          for (const repo of regularRepos) {
-            const repoPath = join(session.path, repo.dir);
-            try {
-              await rm(repoPath, { recursive: true, force: true });
-            } catch {
-              // Ignore cleanup errors
-            }
-          }
-          // Also clean up reference symlinks
-          for (const repo of successfulRefs) {
-            const repoPath = join(session.path, repo.dir);
-            try {
-              await rm(repoPath, { recursive: true, force: true });
-            } catch {
-              // Ignore cleanup errors
-            }
-          }
-          return { session, cancelled: true };
-        }
+      const results = await runCommands(renderer, {
+        title: "Adding repositories",
+        tasks,
+        showOutput: true,
+        outputLines: 5,
+        allowAbort: true,
+        allowSkip: tasks.length > 1,
+        allowBackground: true,
+        sessionName: session.name,
+      });
 
-        // Clean up skipped repo directories
-        const skippedResults = results.filter((r) => r.outcome === "skipped");
-        for (const skipped of skippedResults) {
-          const repoSpec = skipped.task.label.replace("Cloning ", "");
-          const repo = newRepos.find((r) => `${r.owner}/${r.name}` === repoSpec);
-          if (repo) {
-            const repoPath = join(session.path, repo.dir);
-            try {
-              await rm(repoPath, { recursive: true, force: true });
-            } catch {
-              // Ignore cleanup errors
-            }
+      // Handle aborted operation - return without changes
+      const wasAborted = results.some((r) => r.outcome === "aborted");
+      if (wasAborted) {
+        hideCommandRunner(renderer);
+        // Clean up any partially cloned repos
+        for (const repo of newRepos) {
+          const repoPath = join(session.path, repo.dir);
+          try {
+            await rm(repoPath, { recursive: true, force: true });
+          } catch {
+            // Ignore cleanup errors
           }
         }
+        return { session, cancelled: true };
+      }
 
-        // Check for errors (not skipped/aborted)
-        const errors = results.filter((r) => r.outcome === "error");
-        if (errors.length > 0) {
-          console.error(`\n⚠️  ${errors.length} repository(ies) failed to clone:`);
-          errors.forEach((err) => {
-            console.error(`  ✗ ${err.task.label}`);
-            if (err.error) {
-              console.error(`    ${err.error}`);
-            }
-          });
+      // Clean up skipped repo directories
+      const skippedResults = results.filter((r) => r.outcome === "skipped");
+      for (const skipped of skippedResults) {
+        const repoSpec = skipped.task.label.replace("Cloning ", "");
+        const repo = newRepos.find((r) => `${r.owner}/${r.name}` === repoSpec);
+        if (repo) {
+          const repoPath = join(session.path, repo.dir);
+          try {
+            await rm(repoPath, { recursive: true, force: true });
+          } catch {
+            // Ignore cleanup errors
+          }
         }
       }
 
-      await new Promise((resolve) => setTimeout(resolve, 700));
-      hideCommandRunner(renderer);
-
       // Filter to only successfully cloned repos
-      const successfulCloned = newRepos.filter((repo) => {
-        if (repo.reference) return false; // Reference repos handled separately
+      const successfulRepos = newRepos.filter((repo) => {
         const result = results.find((r) => r.task.label === `Cloning ${repo.owner}/${repo.name}`);
         return result?.outcome === "completed";
       });
 
-      // Combine successful reference and cloned repos
-      const successfulRepos = [...successfulRefs, ...successfulCloned];
+      // Check for errors (not skipped/aborted)
+      const errors = results.filter((r) => r.outcome === "error");
+      if (errors.length > 0) {
+        console.error(`\n⚠️  ${errors.length} repository(ies) failed to clone:`);
+        errors.forEach((err) => {
+          console.error(`  ✗ ${err.task.label}`);
+          if (err.error) {
+            console.error(`    ${err.error}`);
+          }
+        });
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      hideCommandRunner(renderer);
 
       if (successfulRepos.length > 0) {
         const allRepos = [...session.repos, ...successfulRepos];

package/src/flows/chat-to-config.ts

@@ -0,0 +1,373 @@
+import { streamText, type ToolSet } from "ai";
+import { parseRepoSpec, type RepoSpec } from "../schemas";
+import { INCREMENTAL_CHAT_PROMPT, generateRepoHistorySection } from "../prompts/chat-prompt";
+import { z } from "zod";
+import type { ConfigBuilder } from "../config-builder";
+import { listRepoHistory } from "../repo-history";
+
+export interface ChatMessage {
+  role: "user" | "assistant" | "system";
+  content: string;
+}
+
+export interface ChatConfig {
+  repos: string[];
+  skills: string[];
+  goal: string;
+}
+
+export interface ToolCallResult {
+  toolName: string;
+  input: unknown;
+  output: unknown;
+  durationMs: number;
+}
+
+export function configToRepoSpecs(config: ChatConfig): RepoSpec[] {
+  return config.repos.map((spec) => parseRepoSpec(spec));
+}
+
+// ============================================================================
+// INCREMENTAL CHAT MODE - Tools add config items directly
+// ============================================================================
+
+export interface IncrementalChatResult {
+  response: string;
+  toolResults?: ToolCallResult[];
+  error?: string;
+}
+
+/**
+ * Process chat with incremental config building.
+ * Tools directly modify the ConfigBuilder, which emits events to update UI.
+ */
+export async function chatToConfigIncremental(
+  messages: ChatMessage[],
+  configBuilder: ConfigBuilder,
+  onChunk: (chunk: string) => void,
+): Promise<IncrementalChatResult> {
+  const context = messages.map((m) => `${m.role}: ${m.content}`).join("\n");
+  const userMessage = messages.findLast((m) => m.role === "user")?.content ?? "";
+
+  const repoHistory = await generateRepoHistorySection();
+
+  const prompt = INCREMENTAL_CHAT_PROMPT.replace("{{context}}", context)
+    .replace("{{userMessage}}", userMessage)
+    .replace("{{repoHistory}}", repoHistory);
+
+  try {
+    const toolTimings: Map<string, number> = new Map();
+
+    const tools: ToolSet = {
+      // Config building tools
+      add_repo: {
+        title: "add_repo",
+        description: "Add a repository to the workspace configuration",
+        inputSchema: z.object({
+          repo: z.string().describe("Repository in format owner/repo or owner/repo:branch"),
+        }),
+        execute: async ({ repo }) => {
+          const startTime = Date.now();
+
+          // Validate repo exists on GitHub using gh CLI
+          const repoPath = repo.includes(":") ? repo.split(":")[0] : repo;
+          const branch = repo.includes(":") ? repo.split(":")[1] : undefined;
+
+          const validationProc = Bun.spawn(
+            ["gh", "repo", "view", repoPath, "--json", "nameWithOwner"],
+            {
+              stdout: "pipe",
+              stderr: "pipe",
+            },
+          );
+
+          const validationOutput = await new Response(validationProc.stdout).text();
+          const validationStderr = await new Response(validationProc.stderr).text();
+
+          if (validationStderr && !validationOutput) {
+            const duration = Date.now() - startTime;
+            toolTimings.set("add_repo", duration);
+            return {
+              success: false,
+              error: `Repository '${repoPath}' not found on GitHub. Please check the owner and repository name.`,
+              currentRepos: configBuilder.config.repos,
+            };
+          }
+
+          // If branch is specified, validate it exists
+          if (branch) {
+            const branchProc = Bun.spawn(
+              ["gh", "api", `repos/${repoPath}/git/refs/heads/${branch}`],
+              {
+                stdout: "pipe",
+                stderr: "pipe",
+              },
+            );
+
+            const branchOutput = await new Response(branchProc.stdout).text();
+            const branchStderr = await new Response(branchProc.stderr).text();
+
+            if (branchStderr && !branchOutput) {
+              const duration = Date.now() - startTime;
+              toolTimings.set("add_repo", duration);
+              return {
+                success: false,
+                error: `Branch '${branch}' not found in repository '${repoPath}'.`,
+                currentRepos: configBuilder.config.repos,
+              };
+            }
+          }
+
+          const added = configBuilder.addRepo(repo);
+          const duration = Date.now() - startTime;
+          toolTimings.set("add_repo", duration);
+          return {
+            success: added,
+            message: added ? `Added ${repo}` : `${repo} already in config`,
+            currentRepos: configBuilder.config.repos,
+          };
+        },
+      },
+      add_skill: {
+        title: "add_skill",
+        description: "Add a skill or package to install in the workspace",
+        inputSchema: z.object({
+          skill: z.string().describe("Skill or package name to install"),
+        }),
+        execute: async ({ skill }) => {
+          const startTime = Date.now();
+          const added = configBuilder.addSkill(skill);
+          const duration = Date.now() - startTime;
+          toolTimings.set("add_skill", duration);
+          return {
+            success: added,
+            message: added ? `Added skill ${skill}` : `${skill} already in config`,
+            currentSkills: configBuilder.config.skills,
+          };
+        },
+      },
+      set_goal: {
+        title: "set_goal",
+        description: "Set the goal/purpose for this workspace session",
+        inputSchema: z.object({
+          goal: z.string().describe("Brief description of what the user wants to accomplish"),
+        }),
+        execute: async ({ goal }) => {
+          const startTime = Date.now();
+          configBuilder.setGoal(goal);
+          const duration = Date.now() - startTime;
+          toolTimings.set("set_goal", duration);
+          return {
+            success: true,
+            message: `Goal set to: ${goal}`,
+          };
+        },
+      },
+      // Research tools (existing)
+      list_repos: {
+        title: "list_repos",
+        description: "List all repositories for a given owner/organization",
+        inputSchema: z.object({
+          owner: z.string(),
+          limit: z.number().optional(),
+          topic: z.string().optional(),
+        }),
+        execute: async ({ owner, limit, topic }) => {
+          const startTime = Date.now();
+          const args = [
+            "repo",
+            "list",
+            owner,
+            "--json",
+            "nameWithOwner",
+            "--jq",
+            ".[].nameWithOwner",
+          ];
+          if (limit) {
+            args.push("--limit", String(limit));
+          }
+          if (topic) {
+            args.push("--topic", topic);
+          }
+          const proc = Bun.spawn(["gh", ...args], {
+            stdout: "pipe",
+            stderr: "pipe",
+          });
+          const output = await new Response(proc.stdout).text();
+          const result = {
+            repos: output.trim().split("\n").filter(Boolean),
+          };
+          const duration = Date.now() - startTime;
+          toolTimings.set("list_repos", duration);
+          return result;
+        },
+      },
+      view_issue: {
+        title: "view_issue",
+        description:
+          "View a GitHub issue. Accepts either a full GitHub URL or owner/repo with issue number.",
+        inputSchema: z.object({
+          url: z.string().optional().describe("Full GitHub issue URL"),
+          owner: z.string().optional().describe("Repository owner"),
+          repo: z.string().optional().describe("Repository name"),
+          issue: z.number().optional().describe("Issue number"),
+        }),
+        execute: async ({ url, owner, repo, issue }) => {
+          const startTime = Date.now();
+
+          let repoPath: string;
+          let issueNumber: number;
+
+          if (url) {
+            // Parse URL like https://github.com/owner/repo/issues/123
+            const match = url.match(/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/);
+            if (!match) {
+              return { error: "Invalid GitHub issue URL", markdown: "" };
+            }
+            repoPath = `${match[1]}/${match[2]}`;
+            issueNumber = parseInt(match[3], 10);
+          } else if (owner && repo && issue) {
+            repoPath = `${owner}/${repo}`;
+            issueNumber = issue;
+          } else {
+            return { error: "Provide either a URL or owner/repo/issue", markdown: "" };
+          }
+
+          const proc = Bun.spawn(
+            [
+              "gh",
+              "issue",
+              "view",
+              String(issueNumber),
+              "--repo",
+              repoPath,
+              "--json",
+              "title,body,state,author,labels,createdAt,comments,url",
+            ],
+            {
+              stdout: "pipe",
+              stderr: "pipe",
+            },
+          );
+
+          const output = await new Response(proc.stdout).text();
+          const stderr = await new Response(proc.stderr).text();
+
+          if (stderr && !output) {
+            return { error: stderr.trim(), markdown: "" };
+          }
+
+          try {
+            const data = JSON.parse(output);
+            const labels = data.labels?.map((l: { name: string }) => l.name).join(", ") || "None";
+            const commentCount = data.comments?.length || 0;
+
+            const markdown = `## ${data.title}
+
+**Repository:** ${repoPath}
+**Issue:** #${issueNumber}
+**State:** ${data.state}
+**Author:** ${data.author?.login || "Unknown"}
+**Labels:** ${labels}
+**Created:** ${new Date(data.createdAt).toLocaleDateString()}
+**Comments:** ${commentCount}
+**URL:** ${data.url}
+
+---
+
+${data.body || "*No description provided*"}`;
+
+            const duration = Date.now() - startTime;
+            toolTimings.set("view_issue", duration);
+
+            return { markdown, title: data.title, state: data.state, url: data.url, repoPath };
+          } catch {
+            return { error: "Failed to parse issue data", markdown: "" };
+          }
+        },
+      },
+      list_repo_history: {
+        title: "list_repo_history",
+        description:
+          "List previously used repositories from history. Useful when user mentions 'my repos' or wants to reuse repos.",
+        inputSchema: z.object({
+          owner: z.string().optional().describe("Filter by repository owner/organization"),
+          limit: z.number().optional().describe("Maximum number of results to return"),
+        }),
+        execute: async ({ owner, limit }) => {
+          const startTime = Date.now();
+          const items = await listRepoHistory(limit ?? 50);
+          const filtered = owner
+            ? items.filter((item) => item.owner.toLowerCase() === owner.toLowerCase())
+            : items;
+          const duration = Date.now() - startTime;
+          toolTimings.set("list_repo_history", duration);
+          return {
+            repos: filtered.map((item) => ({
+              spec: item.spec,
+              owner: item.owner,
+              name: item.name,
+              branch: item.branch,
+              timesUsed: item.timesUsed,
+              lastUsed: item.lastUsed,
+            })),
+          };
+        },
+      },
+    };
+
+    const result = streamText({
+      model: "moonshotai/kimi-k2.5",
+      temperature: 0.7,
+      prompt,
+      tools,
+      maxSteps: 100,
+    } as any);
+
+    let response = "";
+    const toolResults: ToolCallResult[] = [];
+
+    for await (const chunk of result.fullStream) {
+      switch (chunk.type) {
+        case "text-delta": {
+          const text = (chunk as any).text ?? (chunk as any).textDelta ?? "";
+          response += text;
+          onChunk(text);
+          break;
+        }
+        case "tool-call": {
+          // Tool is being called - show indicator to user
+          onChunk(`\n[${chunk.toolName}...]\n`);
+          break;
+        }
+        case "tool-result": {
+          const durationMs = toolTimings.get(chunk.toolName) || 0;
+          const chunkAny = chunk as any;
+          toolResults.push({
+            toolName: chunk.toolName,
+            input: chunkAny.input ?? chunkAny.args,
+            output: chunkAny.output ?? chunkAny.result,
+            durationMs,
+          });
+          break;
+        }
+        case "error": {
+          console.error("Stream error:", chunk.error);
+          break;
+        }
+      }
+    }
+
+    response = response.trim();
+
+    return {
+      response,
+      toolResults: toolResults.length > 0 ? toolResults : undefined,
+    };
+  } catch (llmError) {
+    return {
+      response: "",
+      error: `LLM error: ${llmError instanceof Error ? llmError.message : String(llmError)}`,
+    };
+  }
+}