tmux-ide 1.0.0

package/src/config.js

@@ -0,0 +1,259 @@
+import { resolve } from "node:path";
+import { readConfig, writeConfig } from "./lib/yaml-io.js";
+import { getByPath, setByPath } from "./lib/dot-path.js";
+import { outputError } from "./lib/output.js";
+
+export async function config(targetDir, { json, action, args } = {}) {
+  const dir = resolve(targetDir ?? ".");
+
+  switch (action) {
+    case "dump":
+      return dumpConfig(dir, { json });
+    case "set":
+      return setConfig(dir, args, { json });
+    case "add-pane":
+      return addPane(dir, args, { json });
+    case "remove-pane":
+      return removePane(dir, args, { json });
+    case "add-row":
+      return addRow(dir, args, { json });
+    case "enable-team":
+      return enableTeam(dir, args, { json });
+    case "disable-team":
+      return disableTeam(dir, { json });
+    default:
+      return dumpConfig(dir, { json });
+  }
+}
+
+function dumpConfig(dir, { json }) {
+  let cfg;
+  try {
+    ({ config: cfg } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR", { json });
+    return;
+  }
+
+  if (json) {
+    console.log(JSON.stringify(cfg, null, 2));
+  } else {
+    // Pretty print for humans
+    console.log(JSON.stringify(cfg, null, 2));
+  }
+}
+
+function setConfig(dir, args, { json }) {
+  const [dotpath, ...rest] = args;
+  if (!dotpath || rest.length === 0) {
+    outputError("Usage: tmux-ide config set <dotpath> <value>", "USAGE", { json });
+    return;
+  }
+
+  let cfg;
+  try {
+    ({ config: cfg } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR", { json });
+    return;
+  }
+
+  let value = rest.join(" ");
+  // Try to parse as number or boolean
+  if (value === "true") value = true;
+  else if (value === "false") value = false;
+  else if (/^\d+$/.test(value)) value = parseInt(value);
+
+  setByPath(cfg, dotpath, value);
+  writeConfig(dir, cfg);
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, path: dotpath, value }, null, 2));
+  } else {
+    console.log(`Set ${dotpath} = ${JSON.stringify(value)}`);
+  }
+}
+
+function addPane(dir, args, { json }) {
+  const { row, title, command, size } = parseNamedArgs(args);
+  if (row === undefined) {
+    outputError("Usage: tmux-ide config add-pane --row <N> --title <T> [--command <C>] [--size <S>]", "USAGE", { json });
+    return;
+  }
+
+  let cfg;
+  try {
+    ({ config: cfg } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR", { json });
+    return;
+  }
+
+  const rowIdx = parseInt(row);
+  if (!cfg.rows?.[rowIdx]) {
+    outputError(`Row ${rowIdx} does not exist`, "INVALID_ROW", { json });
+    return;
+  }
+
+  const pane = {};
+  if (title) pane.title = title;
+  if (command) pane.command = command;
+  if (size) pane.size = size;
+
+  cfg.rows[rowIdx].panes.push(pane);
+  writeConfig(dir, cfg);
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, row: rowIdx, pane }, null, 2));
+  } else {
+    console.log(`Added pane "${title ?? "untitled"}" to row ${rowIdx}`);
+  }
+}
+
+function removePane(dir, args, { json }) {
+  const { row, pane } = parseNamedArgs(args);
+  if (row === undefined || pane === undefined) {
+    outputError("Usage: tmux-ide config remove-pane --row <N> --pane <M>", "USAGE", { json });
+    return;
+  }
+
+  let cfg;
+  try {
+    ({ config: cfg } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR", { json });
+    return;
+  }
+
+  const rowIdx = parseInt(row);
+  const paneIdx = parseInt(pane);
+
+  if (!cfg.rows?.[rowIdx]?.panes?.[paneIdx]) {
+    outputError(`Pane ${paneIdx} in row ${rowIdx} does not exist`, "INVALID_PANE", { json });
+    return;
+  }
+
+  const removed = cfg.rows[rowIdx].panes.splice(paneIdx, 1)[0];
+  writeConfig(dir, cfg);
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, row: rowIdx, pane: paneIdx, removed }, null, 2));
+  } else {
+    console.log(`Removed pane ${paneIdx} ("${removed.title ?? "untitled"}") from row ${rowIdx}`);
+  }
+}
+
+function addRow(dir, args, { json }) {
+  const { size } = parseNamedArgs(args);
+
+  let cfg;
+  try {
+    ({ config: cfg } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR", { json });
+    return;
+  }
+
+  const row = { panes: [{ title: "Shell" }] };
+  if (size) row.size = size;
+
+  cfg.rows = cfg.rows ?? [];
+  cfg.rows.push(row);
+  writeConfig(dir, cfg);
+
+  const rowIdx = cfg.rows.length - 1;
+  if (json) {
+    console.log(JSON.stringify({ ok: true, row: rowIdx, size: size ?? null }, null, 2));
+  } else {
+    console.log(`Added row ${rowIdx}${size ? ` (${size})` : ""}`);
+  }
+}
+
+function enableTeam(dir, args, { json }) {
+  const { name } = parseNamedArgs(args);
+
+  let cfg;
+  try {
+    ({ config: cfg } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR", { json });
+    return;
+  }
+
+  const teamName = name ?? cfg.name ?? "my-team";
+  cfg.team = { name: teamName };
+
+  // Find claude panes and assign roles: first as lead, rest as teammates
+  let leadAssigned = false;
+  for (const row of cfg.rows ?? []) {
+    for (const pane of row.panes ?? []) {
+      if (pane.command === "claude" || pane.role === "lead" || pane.role === "teammate") {
+        if (!leadAssigned) {
+          pane.role = "lead";
+          leadAssigned = true;
+        } else {
+          pane.role = "teammate";
+        }
+      }
+    }
+  }
+
+  writeConfig(dir, cfg);
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, team: cfg.team, roles: summarizeRoles(cfg) }, null, 2));
+  } else {
+    console.log(`Enabled agent team "${teamName}"`);
+  }
+}
+
+function disableTeam(dir, { json }) {
+  let cfg;
+  try {
+    ({ config: cfg } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR", { json });
+    return;
+  }
+
+  delete cfg.team;
+  for (const row of cfg.rows ?? []) {
+    for (const pane of row.panes ?? []) {
+      delete pane.role;
+      delete pane.task;
+    }
+  }
+
+  writeConfig(dir, cfg);
+
+  if (json) {
+    console.log(JSON.stringify({ ok: true, disabled: true }, null, 2));
+  } else {
+    console.log("Disabled agent team");
+  }
+}
+
+function summarizeRoles(cfg) {
+  const roles = [];
+  for (let i = 0; i < (cfg.rows ?? []).length; i++) {
+    for (let j = 0; j < (cfg.rows[i].panes ?? []).length; j++) {
+      const p = cfg.rows[i].panes[j];
+      if (p.role) {
+        roles.push({ row: i, pane: j, title: p.title ?? null, role: p.role });
+      }
+    }
+  }
+  return roles;
+}
+
+function parseNamedArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--") && i + 1 < args.length) {
+      const key = args[i].slice(2);
+      result[key] = args[i + 1];
+      i++;
+    }
+  }
+  return result;
+}

package/src/detect.js

@@ -0,0 +1,178 @@
+import { resolve, basename } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { writeConfig } from "./lib/yaml-io.js";
+
+function fileExists(dir, name) {
+  return existsSync(resolve(dir, name));
+}
+
+function readJson(dir, name) {
+  try {
+    return JSON.parse(readFileSync(resolve(dir, name), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export function detectStack(dir) {
+  const detected = {
+    packageManager: null,
+    frameworks: [],
+    devCommand: null,
+    language: null,
+  };
+
+  // Detect package manager from lockfile
+  if (fileExists(dir, "pnpm-lock.yaml")) detected.packageManager = "pnpm";
+  else if (fileExists(dir, "bun.lockb") || fileExists(dir, "bun.lock")) detected.packageManager = "bun";
+  else if (fileExists(dir, "yarn.lock")) detected.packageManager = "yarn";
+  else if (fileExists(dir, "package-lock.json")) detected.packageManager = "npm";
+
+  const pkg = readJson(dir, "package.json");
+  if (pkg) {
+    detected.language = "javascript";
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    if (deps["next"]) detected.frameworks.push("next");
+    if (deps["convex"]) detected.frameworks.push("convex");
+    if (deps["vite"]) detected.frameworks.push("vite");
+    if (deps["remix"] || deps["@remix-run/node"]) detected.frameworks.push("remix");
+    if (deps["nuxt"]) detected.frameworks.push("nuxt");
+    if (deps["astro"]) detected.frameworks.push("astro");
+    if (deps["svelte"] || deps["@sveltejs/kit"]) detected.frameworks.push("svelte");
+
+    // Detect dev command
+    const pm = detected.packageManager ?? "npm";
+    const run = pm === "npm" ? "npm run" : pm;
+    if (pkg.scripts?.dev) detected.devCommand = `${run} dev`;
+    else if (pkg.scripts?.start) detected.devCommand = `${run} start`;
+  }
+
+  // Python
+  if (fileExists(dir, "pyproject.toml") || fileExists(dir, "requirements.txt")) {
+    detected.language = detected.language ?? "python";
+    try {
+      const pyproject = readFileSync(resolve(dir, "pyproject.toml"), "utf-8");
+      if (pyproject.includes("fastapi")) detected.frameworks.push("fastapi");
+      else if (pyproject.includes("django")) detected.frameworks.push("django");
+      else if (pyproject.includes("flask")) detected.frameworks.push("flask");
+    } catch {}
+  }
+
+  // Rust
+  if (fileExists(dir, "Cargo.toml")) {
+    detected.language = detected.language ?? "rust";
+    detected.frameworks.push("cargo");
+  }
+
+  // Go
+  if (fileExists(dir, "go.mod")) {
+    detected.language = detected.language ?? "go";
+    detected.frameworks.push("go");
+  }
+
+  // Docker
+  if (fileExists(dir, "docker-compose.yml") || fileExists(dir, "docker-compose.yaml")) {
+    detected.frameworks.push("docker");
+  }
+
+  return detected;
+}
+
+export function suggestConfig(dir, detected) {
+  const name = basename(dir);
+  const pm = detected.packageManager ?? "npm";
+  const run = pm === "npm" ? "npm run" : pm;
+
+  // Default: 2 claude panes + shell
+  const config = {
+    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, { json, write } = {}) {
+  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.`);
+    }
+    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("\nRun with --write to create ide.yml, or --json to see the suggested config.");
+}

package/src/detect.test.js

@@ -0,0 +1,115 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { suggestConfig } from "./detect.js";
+
+describe("suggestConfig", () => {
+  it("creates Next.js config with pnpm", () => {
+    const config = suggestConfig("/project", {
+      packageManager: "pnpm",
+      frameworks: ["next"],
+      devCommand: "pnpm dev",
+      language: "javascript",
+    });
+    assert.strictEqual(config.rows[0].size, "70%");
+    assert.strictEqual(config.rows[0].panes.length, 2);
+    const bottom = config.rows[1].panes;
+    assert.strictEqual(bottom[0].title, "Next.js");
+    assert.strictEqual(bottom[0].command, "pnpm dev");
+    assert.strictEqual(bottom[bottom.length - 1].title, "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",
+    });
+    assert.strictEqual(config.rows[0].panes.length, 3);
+    const bottom = config.rows[1].panes;
+    const titles = bottom.map((p) => p.title);
+    assert.ok(titles.includes("Next.js"));
+    assert.ok(titles.includes("Convex"));
+    assert.ok(titles.includes("Shell"));
+  });
+
+  it("creates Go config", () => {
+    const config = suggestConfig("/project", {
+      packageManager: null,
+      frameworks: ["go"],
+      devCommand: null,
+      language: "go",
+    });
+    const bottom = config.rows[1].panes;
+    assert.strictEqual(bottom[0].title, "Go");
+    assert.strictEqual(bottom[0].command, "go run .");
+  });
+
+  it("creates Cargo config", () => {
+    const config = suggestConfig("/project", {
+      packageManager: null,
+      frameworks: ["cargo"],
+      devCommand: null,
+      language: "rust",
+    });
+    const bottom = config.rows[1].panes;
+    assert.strictEqual(bottom[0].title, "Cargo");
+    assert.strictEqual(bottom[0].command, "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;
+    assert.strictEqual(bottom[0].title, "Dev Server");
+    assert.strictEqual(bottom[0].command, "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;
+    assert.strictEqual(bottom.length, 1);
+    assert.strictEqual(bottom[0].title, "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;
+    assert.strictEqual(bottom[0].command, "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;
+    assert.strictEqual(bottom[0].command, "bun dev");
+  });
+
+  it("uses project directory basename as session name", () => {
+    const config = suggestConfig("/home/user/my-app", {
+      packageManager: null,
+      frameworks: [],
+      devCommand: null,
+      language: null,
+    });
+    assert.strictEqual(config.name, "my-app");
+  });
+});

package/src/doctor.js

@@ -0,0 +1,82 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+function check(label, fn, { optional = false } = {}) {
+  try {
+    const result = fn();
+    return { label, pass: true, detail: result, optional };
+  } catch (e) {
+    return { label, pass: false, detail: e.message, optional };
+  }
+}
+
+export async function doctor({ json } = {}) {
+  const checks = [];
+
+  checks.push(
+    check("tmux installed", () => {
+      execSync("which tmux", { stdio: "ignore" });
+      return "found";
+    })
+  );
+
+  checks.push(
+    check("tmux version ≥ 3.0", () => {
+      const version = execSync("tmux -V", { encoding: "utf-8" }).trim();
+      const num = parseFloat(version.replace(/[^0-9.]/g, ""));
+      if (num < 3.0) throw new Error(`${version} (need ≥ 3.0)`);
+      return version;
+    })
+  );
+
+  checks.push(
+    check("Node.js ≥ 18", () => {
+      const major = parseInt(process.versions.node.split(".")[0]);
+      if (major < 18) throw new Error(`Node ${process.versions.node} (need ≥ 18)`);
+      return `v${process.versions.node}`;
+    })
+  );
+
+  checks.push(
+    check("256-color terminal", () => {
+      const term = process.env.TERM ?? "";
+      if (!term.includes("256color") && !term.includes("ghostty") && !term.includes("kitty") && term !== "tmux-256color") {
+        throw new Error(`$TERM is "${term}"`);
+      }
+      return term;
+    })
+  );
+
+  checks.push(
+    check("ide.yml exists", () => {
+      const path = resolve(".", "ide.yml");
+      if (!existsSync(path)) throw new Error("not found in current directory");
+      return "found";
+    })
+  );
+
+  checks.push(
+    check("Claude Code agent teams", () => {
+      if (process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS !== "1") {
+        throw new Error("not set (enable with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1)");
+      }
+      return "enabled";
+    }, { optional: true })
+  );
+
+  if (json) {
+    const allPass = checks.every((c) => c.pass || c.optional);
+    console.log(JSON.stringify({ ok: allPass, checks }, null, 2));
+    return;
+  }
+
+  for (const c of checks) {
+    const icon = c.pass ? "✓" : c.optional ? "○" : "✗";
+    const color = c.pass ? "\x1b[32m" : c.optional ? "\x1b[33m" : "\x1b[31m";
+    console.log(`${color}${icon}\x1b[0m ${c.label} — ${c.detail}`);
+  }
+
+  const allPass = checks.every((c) => c.pass);
+  if (!allPass) process.exitCode = 1;
+}