@tdk-landscape/tdk-cli-core 1.3.44 → 1.3.48

package/cli/src/commands/__tests__/saas-starter-integration.test.ts

@@ -0,0 +1,196 @@
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+// Get the CLI bin path dynamically
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLI_BIN_PATH = join(__dirname, "..", "..", "..", "bin", "tdk.js");
+
+// `tdk doctor` requires these (see REQUIRED_ENV_VARS in ../../utils/env-validator.ts);
+// an empty .env satisfies `tdk project`'s docker-compose validation but leaves doctor
+// reporting "Environment not ready". Use the same defaults env-validator would generate.
+function writeTestEnvFile(starterRoot: string) {
+  writeFileSync(
+    join(starterRoot, ".env"),
+    "VERDACCIO_URL_DOCKER=http://verdaccio:4873\nTILT_ENV=dev\nDB_PASSWORD=test-password\n",
+  );
+}
+
+// tdk-cli-extensions is a sibling checkout, not a dependency of this repo, so its
+// location varies per machine. Respect an explicit override, then fall back to the
+// conventional sibling-directory layout (both repos checked out next to each other),
+// instead of hardcoding one contributor's absolute path.
+const REPO_ROOT = join(__dirname, "..", "..", "..", "..");
+const EXTENSION_SOURCE =
+  process.env.TDK_EXTENSION_SOURCE ?? join(REPO_ROOT, "..", "tdk-cli-extensions");
+const EXTENSION_SOURCE_AVAILABLE = existsSync(EXTENSION_SOURCE);
+
+describe.skipIf(!EXTENSION_SOURCE_AVAILABLE)("saas-starter cloning and discovery", () => {
+  if (!EXTENSION_SOURCE_AVAILABLE) {
+    console.warn(
+      `Skipping saas-starter integration tests: tdk-cli-extensions not found at ${EXTENSION_SOURCE}. ` +
+        "Set TDK_EXTENSION_SOURCE to its checkout path to run these.",
+    );
+  }
+
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `tdk-saas-test-${Date.now()}`);
+  });
+
+  afterEach(() => {
+    try {
+      // Safety: only delete if path is under tmpdir and contains our test marker
+      if (
+        testDir &&
+        testDir.startsWith(tmpdir()) &&
+        testDir.includes("tdk-saas-test-") &&
+        testDir.length > 20
+      ) {
+        execSync(`rm -rf "${testDir}"`, { stdio: "pipe" });
+      }
+    } catch {
+      // cleanup best-effort
+    }
+  });
+
+  /**
+   * Verifies that `tdk project saas` clones the repo correctly with required
+   * structure (services/stack/service/service.json files).
+   */
+  it("should clone saas-starter with valid file structure", () => {
+    const cwd = testDir;
+    execSync(`mkdir -p "${cwd}"`, { stdio: "pipe" });
+
+    const result = execSync(`cd "${cwd}" && bun "${CLI_BIN_PATH}" project saas --yes`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+    });
+
+    expect(result).toContain("Cloned");
+    expect(existsSync(join(cwd, "tdk-saas-starter", "services"))).toBe(true);
+
+    // Verify all 4 saas services exist with valid service.json
+    const services = [
+      "services/app/dashboard-api/service.json",
+      "services/app/dashboard-app/service.json",
+      "services/billing/billing-api/service.json",
+      "services/billing/checkout-app/service.json",
+    ];
+
+    for (const svc of services) {
+      const path = join(cwd, "tdk-saas-starter", svc);
+      expect(existsSync(path)).toBe(true);
+      const content = readFileSync(path, "utf-8");
+      const manifest = JSON.parse(content);
+      expect(manifest).toHaveProperty("appName");
+      expect(manifest).toHaveProperty("stack");
+      expect(manifest.healthCheck).toBeDefined();
+    }
+  }, 30000); // 30s: clones the real saas-starter repo over the network
+
+  /**
+   * Verifies that `tdk project --yes` (after cloning) correctly discovers
+   * the existing service stacks (app, billing) from service.json files and
+   * auto-populates them in project.json's pre_alpha services, so that
+   * `tdk up` will enable them (before fix: they were silently filtered out
+   * in Tilt discovery).
+   */
+  it("should auto-populate discovered services in project.json", () => {
+    const cwd = testDir;
+    execSync(`mkdir -p "${cwd}"`, { stdio: "pipe" });
+
+    // Clone
+    execSync(`cd "${cwd}" && bun "${CLI_BIN_PATH}" project saas --yes`, {
+      stdio: "pipe",
+    });
+
+    const starterRoot = join(cwd, "tdk-saas-starter");
+    writeTestEnvFile(starterRoot);
+
+    // Generate project config
+    execSync(
+      `cd "${starterRoot}" && TDK_EXTENSION_SOURCE="${EXTENSION_SOURCE}" bun "${CLI_BIN_PATH}" project --yes`,
+      { stdio: "pipe" }
+    );
+
+    // Verify project.json has services populated
+    const projectJsonPath = join(starterRoot, ".tdk", "project.json");
+    expect(existsSync(projectJsonPath)).toBe(true);
+
+    const projectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+    expect(projectJson.phases.pre_alpha.enabledStacks).toContain("app");
+    expect(projectJson.phases.pre_alpha.enabledStacks).toContain("billing");
+  }, 30000); // 30s: clones the real saas-starter repo over the network
+
+  /**
+   * Verifies that spec.master is generated with PRE_ALPHA_RESOURCES dict
+   * containing the discovered stacks, so that Tilt's should_enable() check
+   * will allow them to pass through (before fix: PRE_ALPHA_RESOURCES was empty,
+   * and only infra resources appeared in `tilt get uiresources`).
+   */
+  it("should generate spec.master with discovered services in PRE_ALPHA_RESOURCES", () => {
+    const cwd = testDir;
+    execSync(`mkdir -p "${cwd}"`, { stdio: "pipe" });
+
+    execSync(`cd "${cwd}" && bun ${CLI_BIN_PATH} project saas --yes`, {
+      stdio: "pipe",
+    });
+
+    const starterRoot = join(cwd, "tdk-saas-starter");
+    writeTestEnvFile(starterRoot);
+
+    execSync(
+      `cd "${starterRoot}" && TDK_EXTENSION_SOURCE="${EXTENSION_SOURCE}" bun ${CLI_BIN_PATH} project --yes`,
+      { stdio: "pipe" }
+    );
+
+    const specPath = join(starterRoot, ".tdk", ".tdk-out", "spec.master");
+    expect(existsSync(specPath)).toBe(true);
+
+    const specContent = readFileSync(specPath, "utf-8");
+
+    // Before fix: PRE_ALPHA_RESOURCES = { }
+    // After fix: PRE_ALPHA_RESOURCES = { "app": True, "billing": True, }
+    expect(specContent).toContain('PRE_ALPHA_RESOURCES = {');
+    expect(specContent).toMatch(/"app":\s*True/);
+    expect(specContent).toMatch(/"billing":\s*True/);
+    expect(specContent).toContain('FOCUS_PRE_ALPHA = list(PRE_ALPHA_RESOURCES.keys())');
+  });
+
+  /**
+   * Verifies that `tdk doctor` correctly reports master configs as present
+   * (they are in .tdk/.tdk-out/, not the project root).
+   */
+  it("should pass doctor check after project init", () => {
+    const cwd = testDir;
+    execSync(`mkdir -p "${cwd}"`, { stdio: "pipe" });
+
+    execSync(`cd "${cwd}" && bun ${CLI_BIN_PATH} project saas --yes`, {
+      stdio: "pipe",
+    });
+
+    const starterRoot = join(cwd, "tdk-saas-starter");
+    writeTestEnvFile(starterRoot);
+
+    execSync(
+      `cd "${starterRoot}" && TDK_EXTENSION_SOURCE="${EXTENSION_SOURCE}" bun ${CLI_BIN_PATH} project --yes`,
+      { stdio: "pipe" }
+    );
+
+    // Doctor should pass (all master configs present)
+    const doctorResult = execSync(`cd "${starterRoot}" && bun "${CLI_BIN_PATH}" doctor`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 60_000,
+    });
+
+    expect(doctorResult).toContain("Environment ready");
+  });
+});

package/cli/src/commands/__tests__/stack-features-e2e.test.ts

@@ -0,0 +1,129 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const repoRoot = resolve(__dirname, "../../../..");
+const cliBin = join(repoRoot, "cli", "bin", "tdk.js");
+
+function runTdk(args: string[], cwd: string): string {
+  return execFileSync("bun", [cliBin, ...args], {
+    cwd,
+    encoding: "utf-8",
+    env: {
+      ...process.env,
+      TDK_EXTENSION_SOURCE: repoRoot,
+    },
+  });
+}
+
+describe("stack feature E2E", () => {
+  let projectRoot = "";
+
+  afterEach(() => {
+    if (projectRoot && projectRoot.startsWith(tmpdir())) {
+      rmSync(projectRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("generates database-management compose from pre_alpha services", () => {
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-stack-feature-"));
+
+    const output = runTdk(["project", "--yes"], projectRoot);
+    expect(output).toContain("Generated: services/platform/database-management/docker-compose.yml");
+
+    const projectJson = JSON.parse(readFileSync(join(projectRoot, ".tdk", "project.json"), "utf-8"));
+    expect(projectJson.stack_features).toBeUndefined();
+    expect(projectJson.phases.pre_alpha.enabledStacks).toContain("database-management");
+
+    const composePath = join(
+      projectRoot,
+      "services",
+      "platform",
+      "database-management",
+      "docker-compose.yml",
+    );
+    expect(existsSync(composePath)).toBe(true);
+
+    const compose = readFileSync(composePath, "utf-8");
+    expect(compose).toContain("Stack feature: database-management");
+    expect(compose).toContain('Source: .tdk/project.json phases.*.enabledStacks includes "database-management"');
+    expect(compose).toContain("container_name: tdk_stack_feature_");
+    expect(compose).toContain("_postgres");
+    expect(compose).toContain("_database");
+
+    const spec = readFileSync(join(projectRoot, ".tdk", ".tdk-out", "spec.master"), "utf-8");
+    expect(spec).toMatch(/"database-management":\s*True/);
+    expect(spec).not.toContain("STACK_FEATURES");
+
+    const tiltignore = readFileSync(join(projectRoot, ".tiltignore"), "utf-8");
+    expect(tiltignore).toContain("**/.autogenerated/**");
+  });
+
+  it("does not keep database-management enabled after it leaves stack services", () => {
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-stack-feature-off-"));
+    runTdk(["project", "--yes"], projectRoot);
+
+    const projectJsonPath = join(projectRoot, ".tdk", "project.json");
+    const projectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+    projectJson.phases.pre_alpha.enabledStacks = projectJson.phases.pre_alpha.enabledStacks.filter(
+      (service: string) => service !== "database-management",
+    );
+    writeFileSync(projectJsonPath, `${JSON.stringify(projectJson, null, 2)}\n`);
+
+    runTdk(["project", "--yes"], projectRoot);
+
+    const spec = readFileSync(join(projectRoot, ".tdk", ".tdk-out", "spec.master"), "utf-8");
+    expect(spec).not.toMatch(/"database-management":\s*True/);
+    expect(spec).not.toContain("STACK_FEATURES");
+  });
+
+  it("dedupes a duplicated service name in project.json instead of emitting a duplicate Starlark key", () => {
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-stack-feature-dupe-"));
+    runTdk(["project", "--yes"], projectRoot);
+
+    const projectJsonPath = join(projectRoot, ".tdk", "project.json");
+    const projectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+    projectJson.phases.pre_alpha.enabledStacks.push("database-management");
+    writeFileSync(projectJsonPath, `${JSON.stringify(projectJson, null, 2)}\n`);
+
+    runTdk(["project"], projectRoot);
+
+    const spec = readFileSync(join(projectRoot, ".tdk", ".tdk-out", "spec.master"), "utf-8");
+    const matches = spec.match(/"database-management":\s*True/g) ?? [];
+    expect(matches.length).toBe(1);
+  });
+
+  it("adds newly discovered unassigned service stacks to pre_alpha on regeneration", () => {
+    projectRoot = mkdtempSync(join(tmpdir(), "tdk-stack-discovery-sync-"));
+    runTdk(["project", "--yes"], projectRoot);
+
+    const serviceDir = join(projectRoot, "services", "billing", "checkout-app");
+    mkdirSync(serviceDir, { recursive: true });
+    writeFileSync(
+      join(serviceDir, "service.json"),
+      `${JSON.stringify(
+        {
+          appName: "checkout-app",
+          appType: "frontend",
+          stack: "billing",
+          port: 3210,
+        },
+        null,
+        2,
+      )}\n`,
+    );
+
+    runTdk(["project", "--yes"], projectRoot);
+
+    const projectJson = JSON.parse(readFileSync(join(projectRoot, ".tdk", "project.json"), "utf-8"));
+    expect(projectJson.phases.pre_alpha.enabledStacks).toContain("billing");
+
+    const spec = readFileSync(join(projectRoot, ".tdk", ".tdk-out", "spec.master"), "utf-8");
+    expect(spec).toMatch(/"billing":\s*True/);
+  });
+});

package/cli/src/commands/__tests__/upgrade.test.ts

@@ -0,0 +1,101 @@
+import { chmodSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const execSyncMock = vi.fn();
+vi.mock("node:child_process", () => ({
+  execSync: (...args: unknown[]) => execSyncMock(...args),
+}));
+
+const { upgradeViaBinary, isWritable } = await import("../upgrade.js");
+import type { BinaryRelease } from "../upgrade.js";
+
+// Regression coverage for: `tdk upgrade` used to only swap the `tdk` binary
+// and leave the bundled tdk-cli/ engine+templates folder next to it stale or
+// missing, so an upgraded binary still crashed with the loadTemplate ENOENT
+// (the exact error this was meant to fix). It must refresh both, every time.
+describe("upgradeViaBinary", () => {
+  let installDir: string;
+  let tdkPath: string;
+  let release: BinaryRelease;
+
+  beforeEach(() => {
+    installDir = mkdtempSync(join(tmpdir(), "tdk-upgrade-test-"));
+    tdkPath = join(installDir, "tdk");
+    release = {
+      tag: "v1.3.21",
+      assetName: "tdk-darwin-arm64",
+      downloadUrl: "https://example.test/tdk-darwin-arm64",
+      engineDownloadUrl: "https://example.test/tdk-cli-engine.tar.gz",
+    };
+    execSyncMock.mockReset();
+    execSyncMock.mockReturnValue("");
+  });
+
+  afterEach(() => {
+    rmSync(installDir, { recursive: true, force: true });
+  });
+
+  function commandsRun(): string[] {
+    return execSyncMock.mock.calls.map((call) => call[0] as string);
+  }
+
+  it("downloads and extracts the bundled engine tarball next to the binary, not just the binary itself", async () => {
+    const ok = await upgradeViaBinary(tdkPath, release);
+    expect(ok).toBe(true);
+
+    const commands = commandsRun();
+    const engineDir = join(installDir, "tdk-cli");
+
+    expect(commands.some((c) => c.includes("curl") && c.includes(release.downloadUrl))).toBe(true);
+    expect(commands.some((c) => c.includes("curl") && c.includes(release.engineDownloadUrl))).toBe(
+      true,
+    );
+    expect(commands.some((c) => c.startsWith("rm -rf") && c.includes(engineDir))).toBe(true);
+    expect(commands.some((c) => c.startsWith("mkdir -p") && c.includes(engineDir))).toBe(true);
+    expect(
+      commands.some(
+        (c) => c.includes("tar -xzf") && c.includes(engineDir) && c.includes("--strip-components=1"),
+      ),
+    ).toBe(true);
+  });
+
+  it("downloads both the binary and the engine tarball before installing either", async () => {
+    await upgradeViaBinary(tdkPath, release);
+
+    const commands = commandsRun();
+    const binaryCurlIndex = commands.findIndex((c) => c.includes(release.downloadUrl));
+    const engineCurlIndex = commands.findIndex((c) => c.includes(release.engineDownloadUrl));
+    const mvIndex = commands.findIndex((c) => c.startsWith("mv "));
+    const tarIndex = commands.findIndex((c) => c.includes("tar -xzf"));
+
+    expect(binaryCurlIndex).toBeGreaterThanOrEqual(0);
+    expect(engineCurlIndex).toBeGreaterThanOrEqual(0);
+    expect(mvIndex).toBeGreaterThan(binaryCurlIndex);
+    expect(mvIndex).toBeGreaterThan(engineCurlIndex);
+    expect(tarIndex).toBeGreaterThan(engineCurlIndex);
+  });
+
+  it("never shells out to sudo, and fails fast without touching the network when the install dir isn't writable", async () => {
+    chmodSync(installDir, 0o555);
+    try {
+      const ok = await upgradeViaBinary(tdkPath, release);
+      expect(ok).toBe(false);
+      expect(execSyncMock).not.toHaveBeenCalled();
+      expect(commandsRun().some((c) => c.includes("sudo"))).toBe(false);
+    } finally {
+      chmodSync(installDir, 0o755);
+    }
+  });
+
+  it("isWritable reflects actual filesystem permissions", () => {
+    expect(isWritable(installDir)).toBe(true);
+    chmodSync(installDir, 0o555);
+    try {
+      expect(isWritable(installDir)).toBe(false);
+    } finally {
+      chmodSync(installDir, 0o755);
+    }
+  });
+});

package/{dist/commands/completion.js → cli/src/commands/completion.ts}

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
+
 const BASH_COMPLETION = `# TDK CLI Bash Completion
 _tdk_completions() {
     local cur prev opts
@@ -58,6 +59,7 @@ _tdk_completions() {
 
 complete -F _tdk_completions tdk
 `;
+
 const ZSH_COMPLETION = `#compdef tdk
 
 # TDK CLI Zsh Completion
@@ -156,6 +158,7 @@ _tdk_stacks_and_resources() {
 
 compdef _tdk tdk
 `;
+
 const FISH_COMPLETION = `# TDK CLI Fish Completion
 
 # Disable file completions for most commands
@@ -213,82 +216,85 @@ complete -c tdk -n '__fish_seen_subcommand_from doctor' -l fix -d 'Attempt to fi
 complete -c tdk -n '__fish_seen_subcommand_from upgrade' -l force -d 'Force upgrade even if on latest'
 complete -c tdk -n '__fish_seen_subcommand_from upgrade' -l dry-run -d 'Show what would be upgraded'
 `;
+
 export const completionCommand = new Command("completion")
-    .description("Generate shell completion scripts")
-    .option("-s, --shell <shell>", "Target shell (bash, zsh, fish)", "bash")
-    .option("-o, --output <path>", "Output file path (default: stdout)")
-    .option("--install", "Install to shell config automatically")
-    .action((options) => {
+  .description("Generate shell completion scripts")
+  .option("-s, --shell <shell>", "Target shell (bash, zsh, fish)", "bash")
+  .option("-o, --output <path>", "Output file path (default: stdout)")
+  .option("--install", "Install to shell config automatically")
+  .action((options) => {
     const shell = options.shell.toLowerCase();
-    let completionScript;
-    let filename;
+
+    let completionScript: string;
+    let filename: string;
+
     switch (shell) {
-        case "bash":
-            completionScript = BASH_COMPLETION;
-            filename = "tdk-completion.bash";
-            break;
-        case "zsh":
-            completionScript = ZSH_COMPLETION;
-            filename = "_tdk";
-            break;
-        case "fish":
-            completionScript = FISH_COMPLETION;
-            filename = "tdk.fish";
-            break;
-        default:
-            console.error(chalk.red(`❌ Unsupported shell: ${shell}`));
-            console.log(chalk.gray("Supported shells: bash, zsh, fish"));
-            process.exit(1);
+      case "bash":
+        completionScript = BASH_COMPLETION;
+        filename = "tdk-completion.bash";
+        break;
+      case "zsh":
+        completionScript = ZSH_COMPLETION;
+        filename = "_tdk";
+        break;
+      case "fish":
+        completionScript = FISH_COMPLETION;
+        filename = "tdk.fish";
+        break;
+      default:
+        console.error(chalk.red(`❌ Unsupported shell: ${shell}`));
+        console.log(chalk.gray("Supported shells: bash, zsh, fish"));
+        process.exit(1);
     }
+
     if (options.install) {
-        const home = homedir();
-        let installPath;
-        let installInstructions;
-        switch (shell) {
-            case "bash": {
-                installPath = join(home, ".bash_completion.d", filename);
-                const bashDir = join(home, ".bash_completion.d");
-                if (!existsSync(bashDir)) {
-                    mkdirSync(bashDir, { recursive: true });
-                }
-                installInstructions = `\n# Add to ~/.bashrc:\nsource ~/.bash_completion.d/${filename}`;
-                break;
-            }
-            case "zsh": {
-                installPath = join(home, ".zsh", "completions", filename);
-                const zshDir = join(home, ".zsh", "completions");
-                if (!existsSync(zshDir)) {
-                    mkdirSync(zshDir, { recursive: true });
-                }
-                installInstructions =
-                    "\n# Add to ~/.zshrc:\nfpath+=(~/.zsh/completions)\nautoload -U compinit && compinit";
-                break;
-            }
-            case "fish": {
-                installPath = join(home, ".config", "fish", "completions", filename);
-                const fishDir = join(home, ".config", "fish", "completions");
-                if (!existsSync(fishDir)) {
-                    mkdirSync(fishDir, { recursive: true });
-                }
-                installInstructions = "\n# Fish completions loaded automatically";
-                break;
-            }
-            default:
-                installPath = "";
-                installInstructions = "";
+      const home = homedir();
+      let installPath: string;
+      let installInstructions: string;
+
+      switch (shell) {
+        case "bash": {
+          installPath = join(home, ".bash_completion.d", filename);
+          const bashDir = join(home, ".bash_completion.d");
+          if (!existsSync(bashDir)) {
+            mkdirSync(bashDir, { recursive: true });
+          }
+          installInstructions = `\n# Add to ~/.bashrc:\nsource ~/.bash_completion.d/${filename}`;
+          break;
         }
-        writeFileSync(installPath, completionScript, "utf-8");
-        console.log(chalk.green(`✅ Installed ${shell} completion to:`));
-        console.log(chalk.cyan(`   ${installPath}`));
-        console.log(chalk.yellow(installInstructions));
-    }
-    else if (options.output) {
-        writeFileSync(options.output, completionScript, "utf-8");
-        console.log(chalk.green(`✅ Written ${shell} completion to:`));
-        console.log(chalk.cyan(`   ${options.output}`));
-    }
-    else {
-        console.log(completionScript);
+        case "zsh": {
+          installPath = join(home, ".zsh", "completions", filename);
+          const zshDir = join(home, ".zsh", "completions");
+          if (!existsSync(zshDir)) {
+            mkdirSync(zshDir, { recursive: true });
+          }
+          installInstructions =
+            "\n# Add to ~/.zshrc:\nfpath+=(~/.zsh/completions)\nautoload -U compinit && compinit";
+          break;
+        }
+        case "fish": {
+          installPath = join(home, ".config", "fish", "completions", filename);
+          const fishDir = join(home, ".config", "fish", "completions");
+          if (!existsSync(fishDir)) {
+            mkdirSync(fishDir, { recursive: true });
+          }
+          installInstructions = "\n# Fish completions loaded automatically";
+          break;
+        }
+        default:
+          installPath = "";
+          installInstructions = "";
+      }
+
+      writeFileSync(installPath, completionScript, "utf-8");
+      console.log(chalk.green(`✅ Installed ${shell} completion to:`));
+      console.log(chalk.cyan(`   ${installPath}`));
+      console.log(chalk.yellow(installInstructions));
+    } else if (options.output) {
+      writeFileSync(options.output, completionScript, "utf-8");
+      console.log(chalk.green(`✅ Written ${shell} completion to:`));
+      console.log(chalk.cyan(`   ${options.output}`));
+    } else {
+      console.log(completionScript);
     }
-});
-//# sourceMappingURL=completion.js.map
+  });