tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/detect.js

@@ -0,0 +1,228 @@
+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,
+        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,
+            ...pkg.devDependencies,
+        };
+        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;
+        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, 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.`);
+            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, framework, reason) {
+    if (!detected.frameworks.includes(framework)) {
+        detected.frameworks.push(framework);
+    }
+    detected.reasons.push(reason);
+}

package/packages/daemon/dist/doctor.d.ts

@@ -0,0 +1,21 @@
+import { type DiscoveredAgent } from "./lib/agent-discovery.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 declare function agentIntegrationRows(agents: DiscoveredAgent[]): CheckResult[];
+export declare function doctor({ json, }?: {
+    json?: boolean;
+}): Promise<void>;
+export {};

package/packages/daemon/dist/doctor.js

@@ -0,0 +1,154 @@
+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.js";
+import { installedSkillVersion } from "./lib/skill-sync.js";
+import { discoverAgents, presentAgents } from "./lib/agent-discovery.js";
+import { findCompiledTui, isBunAvailable } from "./tui/compiled.js";
+/**
+ * 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) {
+    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, 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;
+    }, { 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/dist/embed.d.ts

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

package/packages/daemon/dist/embed.js

@@ -0,0 +1 @@
+export { startEmbeddedDaemon, } from "./lib/daemon-embed.js";

package/packages/daemon/dist/index.d.ts

@@ -0,0 +1,3 @@
+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/dist/index.js

@@ -0,0 +1,2 @@
+export { startEmbeddedDaemon, } from "./embed.js";
+export { clearCanonicalDaemonInfo, isCanonicalDaemonAlive, readCanonicalDaemonInfo, writeCanonicalDaemonInfo, } from "./canonical.js";

package/packages/daemon/dist/init.d.ts

@@ -0,0 +1,4 @@
+export declare function init({ template, json, }?: {
+    template?: string;
+    json?: boolean;
+}): Promise<void>;

package/packages/daemon/dist/init.js

@@ -0,0 +1,174 @@
+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.js";
+import { outputError, printLayout } from "./lib/output.js";
+function copyTemplateSkills(targetDir) {
+    const created = [];
+    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) {
+    const created = [];
+    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) {
+    const created = [];
+    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, name) {
+    const created = [];
+    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) {
+    return templateName === "missions" || templateName.startsWith("agent-team");
+}
+function scaffoldTeamWorkspace(dir, name) {
+    const created = [];
+    created.push(...scaffoldLibraryStubs(dir));
+    created.push(...scaffoldValidationContract(dir));
+    created.push(...scaffoldAgentsMd(dir, name));
+    return created;
+}
+function scaffoldMissionsWorkspace(dir, name) {
+    const created = [];
+    const skillsDir = join(dir, ".tmux-ide", "skills");
+    created.push(...copyTemplateSkills(skillsDir));
+    created.push(...scaffoldTeamWorkspace(dir, name));
+    return created;
+}
+export async function init({ template, json, } = {}) {
+    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;
+        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));
+            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));
+            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/dist/inspect.d.ts

@@ -0,0 +1,54 @@
+import { 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 declare function buildInspection(dir: string, { config, configPath, running, panes, }: {
+    config: IdeConfig;
+    configPath: string;
+    running: boolean;
+    panes: ReturnType<typeof listPanes>;
+}): Inspection;
+export declare function inspect(targetDir: string | undefined, { json }?: {
+    json?: boolean;
+}): Promise<void>;
+export {};