tmux-ide 1.3.1 → 2.0.0

package/src/detect.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from "bun:test";
+import { detectStack, suggestConfig } from "./detect.ts";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+describe("suggestConfig", () => {
+  it("creates Next.js config with pnpm", () => {
+    const config = suggestConfig("/project", {
+      packageManager: "pnpm",
+      frameworks: ["next"],
+      devCommand: "pnpm dev",
+      language: "javascript",
+    });
+    expect(config.rows[0].size).toBe("70%");
+    expect(config.rows[0].panes.length).toBe(2);
+    const bottom = config.rows[1].panes;
+    expect(bottom[0].title).toBe("Next.js");
+    expect(bottom[0].command).toBe("pnpm dev");
+    expect(bottom[bottom.length - 1].title).toBe("Shell");
+  });
+
+  it("creates Next.js + Convex config with 3 Claude panes", () => {
+    const config = suggestConfig("/project", {
+      packageManager: "pnpm",
+      frameworks: ["next", "convex"],
+      devCommand: "pnpm dev",
+      language: "javascript",
+    });
+    expect(config.rows[0].panes.length).toBe(3);
+    const bottom = config.rows[1].panes;
+    const titles = bottom.map((p) => p.title);
+    expect(titles.includes("Next.js")).toBeTruthy();
+    expect(titles.includes("Convex")).toBeTruthy();
+    expect(titles.includes("Shell")).toBeTruthy();
+  });
+
+  it("creates Go config", () => {
+    const config = suggestConfig("/project", {
+      packageManager: null,
+      frameworks: ["go"],
+      devCommand: null,
+      language: "go",
+    });
+    const bottom = config.rows[1].panes;
+    expect(bottom[0].title).toBe("Go");
+    expect(bottom[0].command).toBe("go run .");
+  });
+
+  it("creates Cargo config", () => {
+    const config = suggestConfig("/project", {
+      packageManager: null,
+      frameworks: ["cargo"],
+      devCommand: null,
+      language: "rust",
+    });
+    const bottom = config.rows[1].panes;
+    expect(bottom[0].title).toBe("Cargo");
+    expect(bottom[0].command).toBe("cargo watch -x run");
+  });
+
+  it("falls back to dev command when no framework detected", () => {
+    const config = suggestConfig("/project", {
+      packageManager: "npm",
+      frameworks: [],
+      devCommand: "npm run dev",
+      language: "javascript",
+    });
+    const bottom = config.rows[1].panes;
+    expect(bottom[0].title).toBe("Dev Server");
+    expect(bottom[0].command).toBe("npm run dev");
+  });
+
+  it("creates minimal config with just shell when nothing detected", () => {
+    const config = suggestConfig("/project", {
+      packageManager: null,
+      frameworks: [],
+      devCommand: null,
+      language: null,
+    });
+    const bottom = config.rows[1].panes;
+    expect(bottom.length).toBe(1);
+    expect(bottom[0].title).toBe("Shell");
+  });
+
+  it("uses npm run for npm package manager", () => {
+    const config = suggestConfig("/project", {
+      packageManager: "npm",
+      frameworks: ["next"],
+      devCommand: "npm run dev",
+      language: "javascript",
+    });
+    const bottom = config.rows[1].panes;
+    expect(bottom[0].command).toBe("npm run dev");
+  });
+
+  it("uses bun for bun package manager", () => {
+    const config = suggestConfig("/project", {
+      packageManager: "bun",
+      frameworks: ["vite"],
+      devCommand: "bun dev",
+      language: "javascript",
+    });
+    const bottom = config.rows[1].panes;
+    expect(bottom[0].command).toBe("bun dev");
+  });
+
+  it("uses project directory basename as session name", () => {
+    const config = suggestConfig("/home/user/my-app", {
+      packageManager: null,
+      frameworks: [],
+      devCommand: null,
+      language: null,
+    });
+    expect(config.name).toBe("my-app");
+  });
+});
+
+describe("detectStack reasoning", () => {
+  it("includes reasons for detected frameworks and command choices", () => {
+    const dir = mkdtempSync(join(tmpdir(), "tmux-ide-detect-test-"));
+
+    try {
+      writeFileSync(
+        join(dir, "package.json"),
+        JSON.stringify({
+          dependencies: { next: "latest", convex: "latest" },
+          scripts: { dev: "next dev" },
+        }),
+      );
+      writeFileSync(join(dir, "pnpm-lock.yaml"), "lockfileVersion: 9");
+
+      const detected = detectStack(dir);
+      expect(detected.packageManager).toBe("pnpm");
+      expect(detected.reasons.some((reason) => reason.includes("pnpm-lock.yaml"))).toBeTruthy();
+      expect(detected.reasons.some((reason) => reason.includes('dependency "next"'))).toBeTruthy();
+      expect(detected.reasons.some((reason) => reason.includes("dev command"))).toBeTruthy();
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/detect.ts

@@ -0,0 +1,248 @@
+import { resolve, basename } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { writeConfig } from "./lib/yaml-io.ts";
+import type { IdeConfig } from "./types.ts";
+
+interface DetectedStack {
+  packageManager: string | null;
+  frameworks: string[];
+  devCommand: string | null;
+  language: string | null;
+  reasons: string[];
+}
+
+function fileExists(dir: string, name: string): boolean {
+  return existsSync(resolve(dir, name));
+}
+
+function readJson(dir: string, name: string): Record<string, unknown> | null {
+  try {
+    return JSON.parse(readFileSync(resolve(dir, name), "utf-8")) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+export function detectStack(dir: string): DetectedStack {
+  const detected: DetectedStack = {
+    packageManager: null,
+    frameworks: [],
+    devCommand: null,
+    language: null,
+    reasons: [],
+  };
+
+  // Detect package manager from lockfile
+  if (fileExists(dir, "pnpm-lock.yaml")) {
+    detected.packageManager = "pnpm";
+    detected.reasons.push('Detected pnpm from "pnpm-lock.yaml".');
+  } else if (fileExists(dir, "bun.lockb") || fileExists(dir, "bun.lock")) {
+    detected.packageManager = "bun";
+    detected.reasons.push('Detected bun from "bun.lockb" or "bun.lock".');
+  } else if (fileExists(dir, "yarn.lock")) {
+    detected.packageManager = "yarn";
+    detected.reasons.push('Detected yarn from "yarn.lock".');
+  } else if (fileExists(dir, "package-lock.json")) {
+    detected.packageManager = "npm";
+    detected.reasons.push('Detected npm from "package-lock.json".');
+  }
+
+  const pkg = readJson(dir, "package.json");
+  if (pkg) {
+    detected.language = "javascript";
+    detected.reasons.push('Detected JavaScript from "package.json".');
+    const deps = {
+      ...(pkg.dependencies as Record<string, unknown> | undefined),
+      ...(pkg.devDependencies as Record<string, unknown> | undefined),
+    };
+
+    if (deps["next"]) pushFramework(detected, "next", 'Found dependency "next".');
+    if (deps["convex"]) pushFramework(detected, "convex", 'Found dependency "convex".');
+    if (deps["vite"]) pushFramework(detected, "vite", 'Found dependency "vite".');
+    if (deps["remix"] || deps["@remix-run/node"])
+      pushFramework(detected, "remix", "Found Remix dependency.");
+    if (deps["nuxt"]) pushFramework(detected, "nuxt", 'Found dependency "nuxt".');
+    if (deps["astro"]) pushFramework(detected, "astro", 'Found dependency "astro".');
+    if (deps["svelte"] || deps["@sveltejs/kit"])
+      pushFramework(detected, "svelte", "Found Svelte dependency.");
+
+    // Detect dev command
+    const pm = detected.packageManager ?? "npm";
+    const run = pm === "npm" ? "npm run" : pm;
+    const scripts = pkg.scripts as Record<string, unknown> | undefined;
+    if (scripts?.dev) {
+      detected.devCommand = `${run} dev`;
+      detected.reasons.push(
+        `Using dev command "${detected.devCommand}" from package.json scripts.`,
+      );
+    } else if (scripts?.start) {
+      detected.devCommand = `${run} start`;
+      detected.reasons.push(
+        `Using start command "${detected.devCommand}" from package.json scripts.`,
+      );
+    }
+  }
+
+  // Python
+  if (fileExists(dir, "pyproject.toml") || fileExists(dir, "requirements.txt")) {
+    detected.language = detected.language ?? "python";
+    detected.reasons.push('Detected Python from "pyproject.toml" or "requirements.txt".');
+    try {
+      const pyproject = readFileSync(resolve(dir, "pyproject.toml"), "utf-8");
+      if (pyproject.includes("fastapi"))
+        pushFramework(detected, "fastapi", 'Found "fastapi" in pyproject.toml.');
+      else if (pyproject.includes("django"))
+        pushFramework(detected, "django", 'Found "django" in pyproject.toml.');
+      else if (pyproject.includes("flask"))
+        pushFramework(detected, "flask", 'Found "flask" in pyproject.toml.');
+    } catch {
+      // Ignore missing or unreadable pyproject metadata.
+    }
+  }
+
+  // Rust
+  if (fileExists(dir, "Cargo.toml")) {
+    detected.language = detected.language ?? "rust";
+    detected.reasons.push('Detected Rust from "Cargo.toml".');
+    pushFramework(detected, "cargo", 'Using Cargo workflow from "Cargo.toml".');
+  }
+
+  // Go
+  if (fileExists(dir, "go.mod")) {
+    detected.language = detected.language ?? "go";
+    detected.reasons.push('Detected Go from "go.mod".');
+    pushFramework(detected, "go", 'Using Go workflow from "go.mod".');
+  }
+
+  // Docker
+  if (fileExists(dir, "docker-compose.yml") || fileExists(dir, "docker-compose.yaml")) {
+    pushFramework(
+      detected,
+      "docker",
+      'Detected Docker from "docker-compose.yml" or "docker-compose.yaml".',
+    );
+  }
+
+  if (detected.reasons.length === 0) {
+    detected.reasons.push("No framework-specific signals found; using the generic layout.");
+  }
+
+  return detected;
+}
+
+export function suggestConfig(dir: string, detected: DetectedStack): IdeConfig {
+  const name = basename(dir);
+  const pm = detected.packageManager ?? "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+
+  // Default: 2 claude panes + shell
+  const config: IdeConfig = {
+    name,
+    rows: [
+      {
+        size: "70%",
+        panes: [
+          { title: "Claude 1", command: "claude" },
+          { title: "Claude 2", command: "claude" },
+        ],
+      },
+      {
+        panes: [],
+      },
+    ],
+  };
+
+  const bottom = config.rows[1]!.panes;
+  const frameworks = detected.frameworks;
+
+  // Add 3rd claude pane for complex stacks
+  if (frameworks.length >= 2) {
+    config.rows[0]!.panes.push({ title: "Claude 3", command: "claude" });
+  }
+
+  // Add dev servers
+  if (frameworks.includes("next")) {
+    bottom.push({ title: "Next.js", command: `${run} dev` });
+  } else if (frameworks.includes("vite")) {
+    bottom.push({ title: "Vite", command: `${run} dev` });
+  } else if (frameworks.includes("nuxt")) {
+    bottom.push({ title: "Nuxt", command: `${run} dev` });
+  } else if (frameworks.includes("remix")) {
+    bottom.push({ title: "Remix", command: `${run} dev` });
+  } else if (frameworks.includes("astro")) {
+    bottom.push({ title: "Astro", command: `${run} dev` });
+  } else if (frameworks.includes("svelte")) {
+    bottom.push({ title: "SvelteKit", command: `${run} dev` });
+  } else if (frameworks.includes("fastapi")) {
+    bottom.push({ title: "FastAPI", command: "uvicorn main:app --reload" });
+  } else if (frameworks.includes("django")) {
+    bottom.push({ title: "Django", command: "python manage.py runserver" });
+  } else if (frameworks.includes("flask")) {
+    bottom.push({ title: "Flask", command: "flask run --reload" });
+  } else if (frameworks.includes("cargo")) {
+    bottom.push({ title: "Cargo", command: "cargo watch -x run" });
+  } else if (frameworks.includes("go")) {
+    bottom.push({ title: "Go", command: "go run ." });
+  } else if (detected.devCommand) {
+    bottom.push({ title: "Dev Server", command: detected.devCommand });
+  }
+
+  if (frameworks.includes("convex")) {
+    bottom.push({ title: "Convex", command: "npx convex dev" });
+  }
+
+  // Always add shell
+  bottom.push({ title: "Shell" });
+
+  return config;
+}
+
+export async function detect(
+  targetDir: string | undefined,
+  { json, write }: { json?: boolean; write?: boolean } = {},
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const detected = detectStack(dir);
+  const suggested = suggestConfig(dir, detected);
+
+  if (write) {
+    writeConfig(dir, suggested);
+    if (json) {
+      console.log(JSON.stringify({ detected, suggestedConfig: suggested, written: true }, null, 2));
+    } else {
+      const desc =
+        detected.frameworks.length > 0
+          ? detected.frameworks.join(" + ")
+          : (detected.language ?? "generic project");
+      console.log(`Detected ${desc}. Created ide.yml.`);
+      console.log("\nWhy this layout:");
+      for (const reason of detected.reasons) {
+        console.log(`  - ${reason}`);
+      }
+    }
+    return;
+  }
+
+  if (json) {
+    console.log(JSON.stringify({ detected, suggestedConfig: suggested }, null, 2));
+    return;
+  }
+
+  console.log("Detected stack:");
+  if (detected.packageManager) console.log(`  Package manager: ${detected.packageManager}`);
+  if (detected.language) console.log(`  Language: ${detected.language}`);
+  if (detected.frameworks.length) console.log(`  Frameworks: ${detected.frameworks.join(", ")}`);
+  if (detected.devCommand) console.log(`  Dev command: ${detected.devCommand}`);
+  console.log("\nReasoning:");
+  for (const reason of detected.reasons) {
+    console.log(`  - ${reason}`);
+  }
+  console.log("\nRun with --write to create ide.yml, or --json to see the suggested config.");
+}
+
+function pushFramework(detected: DetectedStack, framework: string, reason: string): void {
+  if (!detected.frameworks.includes(framework)) {
+    detected.frameworks.push(framework);
+  }
+  detected.reasons.push(reason);
+}

package/src/dispatch.ts

@@ -0,0 +1,102 @@
+import { resolve, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { loadMission, loadGoal, loadTask } from "./lib/task-store.ts";
+import { IdeError } from "./lib/errors.ts";
+
+interface DispatchOptions {
+  taskId: string;
+  json?: boolean;
+}
+
+/**
+ * Print task dispatch context to stdout so agents can read it directly.
+ *
+ * 1. If a dispatch file exists (.tasks/dispatch/{id}.md), print it.
+ * 2. Otherwise, build the context from the task store (mission + goal + task).
+ * 3. In JSON mode, output a structured object.
+ * 4. Always end with the completion command hint.
+ */
+export async function dispatch(
+  targetDir: string | null | undefined,
+  opts: DispatchOptions,
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { taskId, json } = opts;
+
+  if (!taskId) {
+    throw new IdeError("Missing task ID. Usage: tmux-ide dispatch <id>", {
+      code: "USAGE",
+    });
+  }
+
+  // Try dispatch file first
+  const dispatchFile = join(dir, ".tasks", "dispatch", `${taskId}.md`);
+  const hasDispatchFile = existsSync(dispatchFile);
+
+  // Always load the task for structured data
+  const task = loadTask(dir, taskId);
+  if (!task && !hasDispatchFile) {
+    throw new IdeError(`Task "${taskId}" not found and no dispatch file exists`, {
+      code: "TASK_NOT_FOUND",
+    });
+  }
+
+  // Load mission and goal context
+  const mission = loadMission(dir);
+  const goal = task?.goal ? loadGoal(dir, task.goal) : null;
+
+  if (json) {
+    const prompt = hasDispatchFile ? readFileSync(dispatchFile, "utf-8") : buildPrompt(dir, task!);
+    const result: Record<string, unknown> = {
+      task: task ?? null,
+      mission: mission ?? null,
+      goal: goal ?? null,
+      prompt,
+    };
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  // Text mode: print the readable prompt
+  if (hasDispatchFile) {
+    const content = readFileSync(dispatchFile, "utf-8");
+    console.log(content);
+  } else {
+    console.log(buildPrompt(dir, task!));
+  }
+
+  // Always print the completion hint
+  console.log("");
+  console.log(`When done: tmux-ide task done ${taskId} --proof "what you did"`);
+}
+
+/**
+ * Build a human-readable prompt from the task store.
+ * Mirrors the logic of buildTaskPrompt() in orchestrator.ts but without
+ * requiring an orchestrator config.
+ */
+function buildPrompt(dir: string, task: NonNullable<ReturnType<typeof loadTask>>): string {
+  let prompt = "";
+
+  const mission = loadMission(dir);
+  if (mission) {
+    prompt += `Mission: ${mission.title}\n`;
+    if (mission.description) prompt += `${mission.description}\n`;
+    prompt += "\n";
+  }
+
+  if (task.goal) {
+    const goal = loadGoal(dir, task.goal);
+    if (goal) {
+      prompt += `Goal: ${goal.title}\n`;
+      if (goal.acceptance) prompt += `Acceptance: ${goal.acceptance}\n`;
+      prompt += "\n";
+    }
+  }
+
+  prompt += `Your Task: ${task.title}\n`;
+  if (task.description) prompt += `${task.description}\n`;
+  prompt += `\nPriority: P${task.priority}\n`;
+  if (task.tags?.length) prompt += `Tags: ${task.tags.join(", ")}\n`;
+  return prompt.trim();
+}

package/src/doctor.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { doctor } from "./doctor.ts";
+
+let tmpDir: string;
+let origCwd: string;
+let origLog: typeof console.log;
+let logged: string[];
+let origExitCode: number | undefined;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-doctor-test-"));
+  origCwd = process.cwd();
+  logged = [];
+  origLog = console.log;
+  origExitCode = process.exitCode;
+  console.log = (...a: string[]) => logged.push(a.join(" "));
+});
+
+afterEach(() => {
+  process.chdir(origCwd);
+  console.log = origLog;
+  process.exitCode = origExitCode;
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("doctor", () => {
+  it("reports tmux installed check", async () => {
+    process.chdir(tmpDir);
+    writeFileSync(join(tmpDir, "ide.yml"), "name: test\nrows:\n  - panes:\n      - title: Shell\n");
+    await doctor({ json: true });
+    const output = JSON.parse(logged[0]);
+    const tmuxCheck = output.checks.find((c) => c.label === "tmux installed");
+    expect(tmuxCheck).toBeTruthy();
+    // tmux is installed in this CI/test environment, so it should pass
+    expect(tmuxCheck.pass).toBe(true);
+  });
+
+  it("reports tmux version check", async () => {
+    process.chdir(tmpDir);
+    writeFileSync(join(tmpDir, "ide.yml"), "name: test\nrows:\n  - panes:\n      - title: Shell\n");
+    await doctor({ json: true });
+    const output = JSON.parse(logged[0]);
+    const versionCheck = output.checks.find((c) => c.label.includes("tmux version"));
+    expect(versionCheck).toBeTruthy();
+  });
+
+  it("reports Node.js version check as passing", async () => {
+    process.chdir(tmpDir);
+    writeFileSync(join(tmpDir, "ide.yml"), "name: test\nrows:\n  - panes:\n      - title: Shell\n");
+    await doctor({ json: true });
+    const output = JSON.parse(logged[0]);
+    const nodeCheck = output.checks.find((c) => c.label.includes("Node.js"));
+    expect(nodeCheck).toBeTruthy();
+    expect(nodeCheck.pass).toBe(true);
+  });
+
+  it("reports ide.yml exists check as passing when present", async () => {
+    process.chdir(tmpDir);
+    writeFileSync(join(tmpDir, "ide.yml"), "name: test\nrows:\n  - panes:\n      - title: Shell\n");
+    await doctor({ json: true });
+    const output = JSON.parse(logged[0]);
+    const ideCheck = output.checks.find((c) => c.label.includes("ide.yml"));
+    expect(ideCheck).toBeTruthy();
+    expect(ideCheck.pass).toBe(true);
+  });
+
+  it("reports ide.yml exists check as failing when absent", async () => {
+    process.chdir(tmpDir);
+    // No ide.yml written
+    await doctor({ json: true });
+    const output = JSON.parse(logged[0]);
+    const ideCheck = output.checks.find((c) => c.label.includes("ide.yml"));
+    expect(ideCheck).toBeTruthy();
+    expect(ideCheck.pass).toBe(false);
+  });
+
+  it("marks agent teams check as optional", async () => {
+    process.chdir(tmpDir);
+    writeFileSync(join(tmpDir, "ide.yml"), "name: test\nrows:\n  - panes:\n      - title: Shell\n");
+    await doctor({ json: true });
+    const output = JSON.parse(logged[0]);
+    const teamsCheck = output.checks.find((c) => c.label.includes("agent teams"));
+    expect(teamsCheck).toBeTruthy();
+    expect(teamsCheck.optional).toBe(true);
+  });
+
+  it("optional checks don't fail the overall result", async () => {
+    process.chdir(tmpDir);
+    writeFileSync(join(tmpDir, "ide.yml"), "name: test\nrows:\n  - panes:\n      - title: Shell\n");
+    // Even if agent teams env var is not set, ok should still be true
+    const origEnv = process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+    delete process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+    try {
+      await doctor({ json: true });
+      const output = JSON.parse(logged[0]);
+      // ok depends on required checks, not optional ones
+      const requiredFailing = output.checks.filter((c) => !c.pass && !c.optional);
+      if (requiredFailing.length === 0) {
+        expect(output.ok).toBe(true);
+      }
+    } finally {
+      if (origEnv !== undefined) {
+        process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = origEnv;
+      }
+    }
+  });
+
+  it("prints human-readable output without --json", async () => {
+    process.chdir(tmpDir);
+    writeFileSync(join(tmpDir, "ide.yml"), "name: test\nrows:\n  - panes:\n      - title: Shell\n");
+    await doctor();
+    // Should have printed colored output with ✓ or ✗
+    expect(logged.length > 0).toBeTruthy();
+    expect(logged.some((l) => l.includes("tmux installed"))).toBeTruthy();
+  });
+});