tmux-ide 2.6.0 → 2.6.1

package/packages/daemon/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/packages/daemon/src/doctor.ts

@@ -0,0 +1,242 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getCurrentVersion, getUpdateStatus } from "./lib/update-check.ts";
+import { installedSkillVersion } from "./lib/skill-sync.ts";
+import { discoverAgents, presentAgents, type DiscoveredAgent } from "./lib/agent-discovery.ts";
+import { findCompiledTui, isBunAvailable } from "./tui/compiled.ts";
+
+interface CheckResult {
+  label: string;
+  pass: boolean;
+  detail: string;
+  optional: boolean;
+}
+
+/**
+ * PURE — the "agent integrations" doctor rows, one per DISCOVERED agent (absent
+ * agents produce nothing — no noise). All rows are optional (informational, they
+ * never fail the overall check):
+ *   - `claude` + integration installed → a passing ✓ "integration installed ✓".
+ *   - `claude` on PATH but NOT installed → a ○ hint pointing at the installer.
+ *   - any other agent on PATH → a passing ✓ noting screen-manifest detection is
+ *     active but there's no lifecycle integration yet.
+ */
+export function agentIntegrationRows(agents: DiscoveredAgent[]): CheckResult[] {
+  return presentAgents(agents).map((agent) => {
+    const label = `agent: ${agent.id}`;
+    if (agent.integration) {
+      return agent.installed
+        ? { label, pass: true, detail: "integration installed ✓", optional: true }
+        : {
+            label,
+            pass: false,
+            detail: `found on PATH — run \`tmux-ide integration install ${agent.id}\` for ground-truth status`,
+            optional: true,
+          };
+    }
+    return {
+      label,
+      pass: true,
+      detail: "found — screen-manifest detection active (no lifecycle integration yet)",
+      optional: true,
+    };
+  });
+}
+
+function check(
+  label: string,
+  fn: () => string,
+  { optional = false }: { optional?: boolean } = {},
+): CheckResult {
+  try {
+    const result = fn();
+    return { label, pass: true, detail: result, optional };
+  } catch (e) {
+    return { label, pass: false, detail: (e as Error).message, optional };
+  }
+}
+
+export async function doctor({
+  json,
+}: {
+  json?: boolean;
+} = {}): Promise<void> {
+  const checks: CheckResult[] = [];
+
+  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;
+      },
+      { optional: true },
+    ),
+  );
+
+  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(
+      "TUI surfaces (cockpit / widgets)",
+      () => {
+        // The OpenTUI/Solid surfaces run either from a dev checkout (bun + the
+        // `.tsx` sources) or, when installed, from the compiled `tmux-ide-tui`
+        // binary. Report which path is live so a "nothing renders" install is
+        // diagnosable instead of silent. Mirrors resolveTuiLaunch's order.
+        const here = dirname(fileURLToPath(import.meta.url));
+        const checkoutEntry = [
+          resolve(here, "../packages/daemon/src/tui/team/index.tsx"),
+          resolve(here, "tui/team/index.tsx"),
+        ].find(existsSync);
+        const binary = findCompiledTui();
+        if (checkoutEntry && isBunAvailable()) return "dev checkout (bun)";
+        if (binary) return `compiled binary (${binary})`;
+        throw new Error(
+          "no dev checkout+bun and no compiled binary — build one with `pnpm build:tui` or install a release that ships it",
+        );
+      },
+      { optional: true },
+    ),
+  );
+
+  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 },
+    ),
+  );
+
+  checks.push(
+    check(
+      "tailscale CLI",
+      () => {
+        const version = execSync("tailscale version", { encoding: "utf-8" }).trim().split("\n")[0]!;
+        return version;
+      },
+      { optional: true },
+    ),
+  );
+
+  checks.push(
+    check(
+      "ngrok CLI",
+      () => {
+        const version = execSync("ngrok version", { encoding: "utf-8" }).trim();
+        return version;
+      },
+      { optional: true },
+    ),
+  );
+
+  checks.push(
+    check(
+      "cloudflared CLI",
+      () => {
+        const version = execSync("cloudflared --version", { encoding: "utf-8" }).trim();
+        return version;
+      },
+      { optional: true },
+    ),
+  );
+
+  checks.push(
+    check(
+      "tmux-ide up to date",
+      () => {
+        const current = getCurrentVersion();
+        const { latest, updateAvailable } = getUpdateStatus({ currentVersion: current });
+        if (updateAvailable) {
+          throw new Error(`v${current} — v${latest} available (run \`tmux-ide update\`)`);
+        }
+        return latest ? `v${current} (latest)` : `v${current} (latest unknown)`;
+      },
+      { optional: true },
+    ),
+  );
+
+  checks.push(
+    check(
+      "Claude Code skill",
+      () => {
+        // The managed skill copy under ~/.claude/skills/tmux-ide should track the
+        // CLI version. Stale/missing → point at the one-command fix; installs and
+        // `tmux-ide update` refresh it automatically, so this is only a nudge.
+        const installed = installedSkillVersion();
+        const current = getCurrentVersion();
+        if (installed === null) {
+          throw new Error("not installed — run `tmux-ide skill-sync`");
+        }
+        if (installed !== current) {
+          throw new Error(`v${installed} (CLI v${current}) — run \`tmux-ide skill-sync\``);
+        }
+        return `in sync (v${installed})`;
+      },
+      { optional: true },
+    ),
+  );
+
+  // Agent integrations: one row per agent discovered on PATH (absent → no row).
+  checks.push(...agentIntegrationRows(discoverAgents()));
+
+  const allPass = checks.every((c) => c.pass || c.optional);
+
+  if (json) {
+    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}`);
+  }
+
+  if (!allPass) process.exitCode = 1;
+}

package/packages/daemon/src/embed.ts

@@ -0,0 +1,5 @@
+export {
+  startEmbeddedDaemon,
+  type EmbeddedDaemonHandle,
+  type EmbeddedDaemonOptions,
+} from "./lib/daemon-embed.ts";

package/packages/daemon/src/index.ts

@@ -0,0 +1,12 @@
+export {
+  startEmbeddedDaemon,
+  type EmbeddedDaemonHandle,
+  type EmbeddedDaemonOptions,
+} from "./embed.ts";
+export {
+  clearCanonicalDaemonInfo,
+  isCanonicalDaemonAlive,
+  readCanonicalDaemonInfo,
+  writeCanonicalDaemonInfo,
+} from "./canonical.ts";
+export type { CanonicalDaemonInfo } from "./canonical.ts";