@ashlr/stack 0.1.1 → 0.3.0

package/src/commands/templates.ts

@@ -1,130 +0,0 @@
-import { defineCommand } from "citty";
-import {
-  addService,
-  assertPhantomInstalled,
-  hasConfig,
-  listProviderNames,
-  listTemplates,
-  loadTemplate,
-  readConfig,
-  writeConfig,
-} from "@ashlr/stack-core";
-import { colors, intro, logEvent, outro, outroError, prompts } from "../ui.ts";
-
-export const templatesCommand = defineCommand({
-  meta: { name: "templates", description: "List or apply starter stack templates." },
-  subCommands: {
-    list: defineCommand({
-      meta: { name: "list", description: "List available templates." },
-      run() {
-        intro("stack templates");
-        const names = listTemplates();
-        if (names.length === 0) {
-          outro(colors.dim("No templates yet."));
-          return;
-        }
-        console.log();
-        for (const name of names) console.log(`  ${colors.cyan("·")} ${colors.bold(name)}`);
-        console.log();
-      },
-    }),
-    apply: defineCommand({
-      meta: {
-        name: "apply",
-        description: "Apply a template — runs `stack add` for each service listed.",
-      },
-      args: {
-        name: { type: "positional", required: true, description: "Template name." },
-        continueOnError: {
-          type: "boolean",
-          default: true,
-          description: "Keep going when a single service fails (default: true).",
-        },
-      },
-      async run({ args }) {
-        const name = String(args.name);
-        intro(`stack templates apply ${name}`);
-
-        const template = await loadTemplate(name);
-        if (!template) {
-          outroError(`Unknown template: ${name}`);
-          return;
-        }
-
-        try {
-          await assertPhantomInstalled();
-        } catch (err) {
-          outroError((err as Error).message);
-          return;
-        }
-
-        // If there's no .stack.toml, seed one from the template up front so
-        // subsequent addService calls have a place to write.
-        if (!hasConfig()) {
-          await writeConfig({
-            stack: {
-              version: "1",
-              project_id: `stk_${Math.random().toString(16).slice(2, 14)}`,
-              template: name,
-            },
-            services: {},
-            environments: template.environments ?? [{ name: "dev", default: true }],
-          });
-        }
-
-        const config = await readConfig();
-        const available = new Set(listProviderNames());
-        const order = Object.keys(template.services ?? {});
-
-        const results: { name: string; status: "ok" | "skip" | "fail"; detail?: string }[] = [];
-
-        for (const name of order) {
-          const spec = template.services[name];
-          if (!spec) continue;
-          const providerName = spec.provider ?? name;
-
-          if (!available.has(providerName)) {
-            results.push({ name, status: "skip", detail: "provider not registered" });
-            continue;
-          }
-          if (config.services[providerName]) {
-            results.push({ name, status: "skip", detail: "already in stack" });
-            continue;
-          }
-
-          const spinner = prompts.spinner();
-          spinner.start(`Adding ${name}…`);
-          try {
-            const result = await addService({
-              providerName,
-              interactive: process.stdout.isTTY === true,
-              log: (event) => {
-                spinner.stop();
-                logEvent(event);
-                spinner.start(`Adding ${name}…`);
-              },
-            });
-            spinner.stop(
-              `${colors.green("●")} ${name} → ${result.displayName} (${result.resourceId})`,
-            );
-            results.push({ name, status: "ok" });
-          } catch (err) {
-            spinner.stop(colors.red(`✗ ${name} failed: ${(err as Error).message}`));
-            results.push({ name, status: "fail", detail: (err as Error).message });
-            if (!args.continueOnError) break;
-          }
-        }
-
-        console.log();
-        const ok = results.filter((r) => r.status === "ok").length;
-        const skip = results.filter((r) => r.status === "skip").length;
-        const fail = results.filter((r) => r.status === "fail").length;
-        if (fail > 0) {
-          outroError(`${ok} added, ${skip} skipped, ${fail} failed.`);
-        } else {
-          outro(colors.green(`${ok} added, ${skip} skipped.`));
-        }
-      },
-    }),
-  },
-});

package/src/commands/upgrade.ts

@@ -1,66 +0,0 @@
-import { defineCommand } from "citty";
-import { colors, intro, outro, outroError } from "../ui.ts";
-
-import pkg from "../../package.json" with { type: "json" };
-
-const PKG = "@ashlr/stack";
-const CURRENT_VERSION = pkg.version;
-
-/**
- * `stack upgrade` — lightweight self-update helper. Checks npm for the latest
- * @ashlr/stack version, prints a hint when a newer one exists. Does not
- * auto-install (too many opinions about bun vs npm vs brew).
- */
-export const upgradeCommand = defineCommand({
-  meta: {
-    name: "upgrade",
-    description: "Check npm for a newer @ashlr/stack release.",
-  },
-  async run() {
-    intro("stack upgrade");
-    try {
-      const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(PKG)}/latest`);
-      if (!res.ok) {
-        outroError(`npm registry returned ${res.status}.`);
-        return;
-      }
-      const body = (await res.json()) as { version?: string };
-      const latest = body.version;
-      if (!latest) {
-        outroError("npm registry response missing version field.");
-        return;
-      }
-      if (latest === CURRENT_VERSION) {
-        outro(colors.green(`Up to date (${latest}).`));
-        return;
-      }
-      if (isNewer(latest, CURRENT_VERSION)) {
-        console.log();
-        console.log(
-          `  ${colors.bold(CURRENT_VERSION)} ${colors.dim("→")} ${colors.bold(colors.green(latest))}`,
-        );
-        console.log();
-        console.log(colors.dim("  Install:"));
-        console.log(colors.dim(`    bun add -g ${PKG}   # or: npm i -g ${PKG}`));
-        console.log();
-        outro(colors.yellow("A newer version is available."));
-      } else {
-        outro(colors.dim(`Local version (${CURRENT_VERSION}) is ahead of npm (${latest}).`));
-      }
-    } catch (err) {
-      outroError(`Couldn't reach npm: ${(err as Error).message}`);
-    }
-  },
-});
-
-function isNewer(a: string, b: string): boolean {
-  const pa = a.split(".").map((x) => parseInt(x, 10));
-  const pb = b.split(".").map((x) => parseInt(x, 10));
-  for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
-    const av = pa[i] ?? 0;
-    const bv = pb[i] ?? 0;
-    if (av > bv) return true;
-    if (av < bv) return false;
-  }
-  return false;
-}

package/src/index.ts

@@ -1,91 +0,0 @@
-#!/usr/bin/env bun
-import { defineCommand, runMain } from "citty";
-import { addCommand } from "./commands/add.ts";
-import { applyCommand } from "./commands/apply.ts";
-import { ciCommand } from "./commands/ci.ts";
-import { cloneCommand } from "./commands/clone.ts";
-import { completionCommand } from "./commands/completion.ts";
-import { depsCommand } from "./commands/deps.ts";
-import { doctorCommand } from "./commands/doctor.ts";
-import { envCommand } from "./commands/env.ts";
-import { execCommand } from "./commands/exec.ts";
-import { importCommand } from "./commands/import.ts";
-import { infoCommand } from "./commands/info.ts";
-import { initCommand } from "./commands/init.ts";
-import { listCommand } from "./commands/list.ts";
-import { loginCommand } from "./commands/login.ts";
-import { openCommand } from "./commands/open.ts";
-import { recommendCommand } from "./commands/recommend.ts";
-import { projectsCommand } from "./commands/projects.ts";
-import { providersCommand } from "./commands/providers.ts";
-import { removeCommand } from "./commands/remove.ts";
-import { scanCommand } from "./commands/scan.ts";
-import { statusCommand } from "./commands/status.ts";
-import { syncCommand } from "./commands/sync.ts";
-import { templatesCommand } from "./commands/templates.ts";
-import { upgradeCommand } from "./commands/upgrade.ts";
-
-// Single source of truth for the CLI version. citty wires this into `--help`
-// and we also use it for `stack --version` (citty ships a standalone flag when
-// `version` is on the meta object — but older citty needs a fallback, below).
-const VERSION = "0.1.0";
-
-const main = defineCommand({
-  meta: {
-    name: "stack",
-    version: VERSION,
-    description:
-      "Ashlr Stack — provision, wire, and operate every third-party service in your project.",
-  },
-  args: {
-    version: {
-      type: "boolean",
-      alias: "v",
-      description: "Print the CLI version and exit.",
-    },
-  },
-  run({ args }) {
-    if (args.version) {
-      console.log(VERSION);
-      return;
-    }
-    // citty 0.1.6 calls the root `run` even when a subcommand matched. Detect
-    // that case by checking process.argv — if the first non-bun arg is a known
-    // subcommand, the subcommand already handled the request and we should
-    // stay silent (otherwise every `stack <sub>` trails a banner and breaks
-    // machine-readable output like `stack recommend --json`).
-    const firstArg = process.argv[2];
-    if (firstArg && !firstArg.startsWith("-")) return;
-    console.log(`\n  ▲ stack ${VERSION}`);
-    console.log("  The control plane for your entire dev stack.");
-    console.log("  Run `stack --help` for the full command list.\n");
-  },
-  subCommands: {
-    init: initCommand,
-    import: importCommand,
-    scan: scanCommand,
-    clone: cloneCommand,
-    add: addCommand,
-    remove: removeCommand,
-    list: listCommand,
-    info: infoCommand,
-    status: statusCommand,
-    env: envCommand,
-    deps: depsCommand,
-    doctor: doctorCommand,
-    exec: execCommand,
-    sync: syncCommand,
-    open: openCommand,
-    login: loginCommand,
-    templates: templatesCommand,
-    providers: providersCommand,
-    recommend: recommendCommand,
-    apply: applyCommand,
-    projects: projectsCommand,
-    ci: ciCommand,
-    completion: completionCommand,
-    upgrade: upgradeCommand,
-  },
-});
-
-runMain(main);

package/src/ui.ts

@@ -1,39 +0,0 @@
-import * as p from "@clack/prompts";
-import pc from "picocolors";
-import type { LogEvent } from "@ashlr/stack-core";
-
-export const colors = pc;
-
-export function banner(): void {
-  console.log();
-  console.log(pc.bold(pc.magenta("  ▲ stack  ")) + pc.dim("— the control plane for your dev stack"));
-  console.log();
-}
-
-export function intro(message: string): void {
-  p.intro(pc.bgMagenta(pc.white(` ${message} `)));
-}
-
-export function outro(message: string): void {
-  p.outro(pc.green(message));
-}
-
-export function outroError(message: string): void {
-  p.outro(pc.red(message));
-  // Use exit(1) (not just exitCode) so the shell gets a real non-zero exit
-  // even if something downstream (citty cleanup, a dangling handle) would
-  // otherwise finish cleanly and swallow the exitCode. CI depends on this.
-  process.exit(1);
-}
-
-export function logEvent(event: LogEvent): void {
-  const prefix =
-    event.level === "error"
-      ? pc.red("✗")
-      : event.level === "warn"
-        ? pc.yellow("⚠")
-        : pc.cyan("›");
-  p.log.message(`${prefix} ${event.msg}`);
-}
-
-export const prompts = p;