tmux-ide 2.1.5 → 2.6.1

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";

package/packages/daemon/src/init.ts

@@ -0,0 +1,211 @@
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  mkdirSync,
+  readdirSync,
+  copyFileSync,
+} from "node:fs";
+import { resolve, join, basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+import { detectStack, suggestConfig } from "./detect.ts";
+import { outputError, printLayout } from "./lib/output.ts";
+import type { IdeConfig } from "./types.ts";
+
+function copyTemplateSkills(targetDir: string): string[] {
+  const created: string[] = [];
+  const templateSkillsDir = resolve(__dirname, "..", "..", "..", "templates", "skills");
+  if (!existsSync(templateSkillsDir)) return created;
+
+  mkdirSync(targetDir, { recursive: true });
+  for (const file of readdirSync(templateSkillsDir)) {
+    if (!file.endsWith(".md")) continue;
+    const destination = join(targetDir, file);
+    copyFileSync(join(templateSkillsDir, file), destination);
+    created.push(destination);
+  }
+  return created;
+}
+
+function scaffoldLibraryStubs(dir: string): string[] {
+  const created: string[] = [];
+  const libraryDir = join(dir, ".tmux-ide", "library");
+  if (!existsSync(libraryDir)) {
+    mkdirSync(libraryDir, { recursive: true });
+    created.push(libraryDir);
+  }
+
+  const archPath = join(libraryDir, "architecture.md");
+  if (!existsSync(archPath)) {
+    writeFileSync(
+      archPath,
+      "# Architecture\n\n<!-- Describe your project's architecture here. This context is injected into agent dispatch prompts. -->\n",
+    );
+    created.push(archPath);
+  }
+
+  const learningsPath = join(libraryDir, "learnings.md");
+  if (!existsSync(learningsPath)) {
+    writeFileSync(
+      learningsPath,
+      "# Learnings\n\n<!-- Task summaries are automatically appended here by the orchestrator. -->\n",
+    );
+    created.push(learningsPath);
+  }
+
+  return created;
+}
+
+function scaffoldValidationContract(dir: string): string[] {
+  const created: string[] = [];
+  const tasksDir = join(dir, ".tasks");
+  if (!existsSync(tasksDir)) {
+    mkdirSync(tasksDir, { recursive: true });
+  }
+
+  const contractPath = join(tasksDir, "validation-contract.md");
+  if (!existsSync(contractPath)) {
+    writeFileSync(
+      contractPath,
+      "# Validation Contract\n\n<!-- Define assertions that the validator agent will verify. Example: -->\n<!-- - VAL-001: All tests pass -->\n<!-- - VAL-002: No TypeScript errors -->\n<!-- - VAL-003: Lint passes with zero warnings -->\n",
+    );
+    created.push(contractPath);
+  }
+
+  return created;
+}
+
+function scaffoldAgentsMd(dir: string, name: string): string[] {
+  const created: string[] = [];
+  const agentsTemplatePath = resolve(__dirname, "..", "..", "..", "templates", "AGENTS.md");
+  if (existsSync(agentsTemplatePath)) {
+    const agentsPath = join(dir, "AGENTS.md");
+    if (!existsSync(agentsPath)) {
+      const content = readFileSync(agentsTemplatePath, "utf-8").replace(/{{name}}/g, name);
+      writeFileSync(agentsPath, content);
+      created.push(agentsPath);
+    }
+  }
+  return created;
+}
+
+function isTeamTemplate(templateName: string): boolean {
+  return templateName === "missions" || templateName.startsWith("agent-team");
+}
+
+function scaffoldTeamWorkspace(dir: string, name: string): string[] {
+  const created: string[] = [];
+  created.push(...scaffoldLibraryStubs(dir));
+  created.push(...scaffoldValidationContract(dir));
+  created.push(...scaffoldAgentsMd(dir, name));
+  return created;
+}
+
+function scaffoldMissionsWorkspace(dir: string, name: string): string[] {
+  const created: string[] = [];
+  const skillsDir = join(dir, ".tmux-ide", "skills");
+  created.push(...copyTemplateSkills(skillsDir));
+  created.push(...scaffoldTeamWorkspace(dir, name));
+  return created;
+}
+
+export async function init({
+  template,
+  json,
+}: { template?: string; json?: boolean } = {}): Promise<void> {
+  const dir = process.cwd();
+  const configPath = resolve(dir, "ide.yml");
+
+  if (existsSync(configPath)) {
+    outputError("ide.yml already exists in this directory", "EXISTS");
+  }
+
+  // If a specific template is requested, use it
+  if (template) {
+    const templatePath = resolve(__dirname, "..", "..", "..", "templates", `${template}.yml`);
+    if (!existsSync(templatePath)) {
+      outputError(`Template "${template}" not found`, "NOT_FOUND");
+    }
+
+    let content = readFileSync(templatePath, "utf-8");
+    const name = basename(dir);
+    content = content.replace(/^name: .+/m, `name: ${name}`);
+    const tmpPath = configPath + ".tmp";
+    writeFileSync(tmpPath, content);
+    renameSync(tmpPath, configPath);
+    let created: string[];
+    if (template === "missions") {
+      created = scaffoldMissionsWorkspace(dir, name);
+    } else if (isTeamTemplate(template)) {
+      created = [
+        ...copyTemplateSkills(join(dir, ".tmux-ide", "skills")),
+        ...scaffoldTeamWorkspace(dir, name),
+      ];
+    } else {
+      created = copyTemplateSkills(join(dir, ".tmux-ide", "skills"));
+    }
+
+    if (json) {
+      console.log(JSON.stringify({ created: true, template, name, paths: created }));
+    } else {
+      console.log(`Created ide.yml from "${template}" template for "${name}"`);
+      const yaml = (await import("js-yaml")).default;
+      printLayout(yaml.load(content) as IdeConfig);
+      for (const createdPath of created) {
+        console.log(`Created ${createdPath.replace(dir + "/", "")}`);
+      }
+    }
+    return;
+  }
+
+  // Smart detection
+  const detected = detectStack(dir);
+  const name = basename(dir);
+
+  if (detected.frameworks.length > 0) {
+    // Use detected stack to generate config
+    const config = suggestConfig(dir, detected);
+    const yaml = (await import("js-yaml")).default;
+    const tmpPath2 = configPath + ".tmp";
+    writeFileSync(tmpPath2, yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' }));
+    renameSync(tmpPath2, configPath);
+
+    const desc = detected.frameworks.join(" + ");
+    if (json) {
+      console.log(JSON.stringify({ created: true, detected: detected.frameworks, name }));
+    } else {
+      console.log(`Detected ${desc}. Created ide.yml for "${name}".`);
+      printLayout(config);
+      console.log("Edit it to customize, then run: tmux-ide");
+    }
+  } else {
+    // Fallback to default template
+    const templatePath = resolve(__dirname, "..", "..", "..", "templates", "default.yml");
+    let content = readFileSync(templatePath, "utf-8");
+    content = content.replace(/^name: .+/m, `name: ${name}`);
+    const tmpPath3 = configPath + ".tmp";
+    writeFileSync(tmpPath3, content);
+    renameSync(tmpPath3, configPath);
+
+    if (json) {
+      console.log(JSON.stringify({ created: true, template: "default", name }));
+    } else {
+      console.log(`Created ide.yml for "${name}"`);
+      const yaml = (await import("js-yaml")).default;
+      printLayout(yaml.load(content) as IdeConfig);
+      console.log("Edit it to configure your workspace, then run: tmux-ide");
+    }
+  }
+
+  // Copy built-in skills if .tmux-ide/skills/ doesn't exist
+  const skillsDir = join(dir, ".tmux-ide", "skills");
+  if (!existsSync(skillsDir)) {
+    const created = copyTemplateSkills(skillsDir);
+    if (created.length > 0 && !json) {
+      console.log("Copied built-in skill templates to .tmux-ide/skills/");
+    }
+  }
+}

package/packages/daemon/src/inspect.ts

@@ -0,0 +1,178 @@
+import { resolve, basename } from "node:path";
+import { readConfig } from "./lib/yaml-io.ts";
+import { validateConfig } from "./validate.ts";
+import { outputError } from "./lib/output.ts";
+import { getSessionState, listPanes } from "@tmux-ide/tmux-bridge";
+import type { IdeConfig } from "./types.ts";
+
+interface ResolvedPane {
+  index: number;
+  title: string | null;
+  command: string | null;
+  dir: string;
+  size: string | null;
+  focus: boolean;
+  role: string | null;
+  task: string | null;
+  env: Record<string, unknown>;
+}
+
+interface ResolvedRow {
+  index: number;
+  size: string | null;
+  panes: ResolvedPane[];
+}
+
+interface Inspection {
+  dir: string;
+  configPath: string;
+  valid: boolean;
+  errors: string[];
+  session: string;
+  before: string | null;
+  summary: { rows: number; panes: number; focus: string | null };
+  team: IdeConfig["team"] | null;
+  theme: IdeConfig["theme"] | null;
+  focus: { row: number; pane: number; title: string | null } | null;
+  rows: ResolvedRow[];
+  rawConfig: IdeConfig;
+  tmux: { running: boolean; panes: ReturnType<typeof listPanes> };
+}
+
+export function buildInspection(
+  dir: string,
+  {
+    config,
+    configPath,
+    running,
+    panes,
+  }: {
+    config: IdeConfig;
+    configPath: string;
+    running: boolean;
+    panes: ReturnType<typeof listPanes>;
+  },
+): Inspection {
+  const errors = validateConfig(config);
+  const rows = Array.isArray(config?.rows) ? config.rows : [];
+  const resolvedRows: ResolvedRow[] = rows.map((row, rowIndex) => ({
+    index: rowIndex,
+    size: row.size ?? null,
+    panes: (Array.isArray(row?.panes) ? row.panes : []).map((pane, paneIndex) => ({
+      index: paneIndex,
+      title: pane.title ?? null,
+      command: pane.command ?? null,
+      dir: pane.dir ?? ".",
+      size: pane.size ?? null,
+      focus: pane.focus === true,
+      role: pane.role ?? null,
+      task: pane.task ?? null,
+      env: pane.env ?? {},
+    })),
+  }));
+
+  const focusPane =
+    resolvedRows
+      .flatMap((row) => row.panes.map((pane) => ({ row: row.index, pane })))
+      .find(({ pane }) => pane.focus) ?? null;
+  const session = config?.name ?? basename(dir);
+
+  return {
+    dir,
+    configPath,
+    valid: errors.length === 0,
+    errors,
+    session,
+    before: config?.before ?? null,
+    summary: {
+      rows: resolvedRows.length,
+      panes: resolvedRows.reduce((sum, row) => sum + row.panes.length, 0),
+      focus: focusPane ? `rows.${focusPane.row}.panes.${focusPane.pane.index}` : null,
+    },
+    team: config?.team ?? null,
+    theme: config?.theme ?? null,
+    focus: focusPane
+      ? {
+          row: focusPane.row,
+          pane: focusPane.pane.index,
+          title: focusPane.pane.title,
+        }
+      : null,
+    rows: resolvedRows,
+    rawConfig: config,
+    tmux: {
+      running,
+      panes,
+    },
+  };
+}
+
+export async function inspect(
+  targetDir: string | undefined,
+  { json }: { json?: boolean } = {},
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+
+  let config;
+  let configPath: string;
+  try {
+    ({ config, configPath } = readConfig(dir));
+  } catch (error) {
+    outputError(`Cannot read ide.yml: ${(error as Error).message}`, "READ_ERROR");
+    return;
+  }
+
+  const session = config?.name ?? basename(dir);
+  const state = getSessionState(session);
+  const panes = state.running ? listPanes(session) : [];
+  const data = buildInspection(dir, { config, configPath, running: state.running, panes });
+
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  console.log(`Directory: ${data.dir}`);
+  console.log(`Config:    ${data.configPath}`);
+  console.log(`Valid:     ${data.valid ? "yes" : "no"}`);
+  console.log(`Session:   ${data.session}`);
+  console.log(`Running:   ${data.tmux.running ? "yes" : "no"}`);
+  console.log(`Rows:      ${data.summary.rows}`);
+  console.log(`Panes:     ${data.summary.panes}`);
+  console.log(`Team:      ${data.team ? data.team.name : "disabled"}`);
+
+  if (data.focus) {
+    console.log(
+      `Focus:     row ${data.focus.row}, pane ${data.focus.pane}${data.focus.title ? ` (${data.focus.title})` : ""}`,
+    );
+  }
+
+  if (!data.valid) {
+    console.log("\nValidation Errors:");
+    for (const error of data.errors) {
+      console.log(`  - ${error}`);
+    }
+  }
+
+  console.log("\nResolved Layout:");
+  for (const row of data.rows) {
+    console.log(`  Row ${row.index}${row.size ? ` (${row.size})` : ""}`);
+    for (const pane of row.panes) {
+      const parts: string[] = [];
+      if (pane.title) parts.push(pane.title);
+      if (pane.command) parts.push(`cmd=${pane.command}`);
+      if (pane.dir && pane.dir !== ".") parts.push(`dir=${pane.dir}`);
+      if (pane.role) parts.push(`role=${pane.role}`);
+      if (pane.focus) parts.push("focus");
+      console.log(`    - pane ${pane.index}: ${parts.join(" | ") || "shell"}`);
+    }
+  }
+
+  if (data.tmux.running && data.tmux.panes.length > 0) {
+    console.log("\nLive Panes:");
+    for (const pane of data.tmux.panes) {
+      const active = pane.active ? " (active)" : "";
+      console.log(`  ${pane.index}: ${pane.title} [${pane.width}x${pane.height}]${active}`);
+    }
+  }
+}