@atolljs/cli 0.0.0-stage → 0.1.5

package/src/io.ts

@@ -0,0 +1,127 @@
+import { createInterface, type Interface } from 'node:readline/promises';
+import { stdin, stdout, stderr } from 'node:process';
+import { styleText } from 'node:util';
+
+/**
+ * Semantic styling — commands print `fmt.accent('cd foo')` instead of raw
+ * ANSI, so `scriptIo` (identity) keeps test output clean and piped runs
+ * emit no escape codes at all.
+ */
+export interface Fmt {
+  /** Bold — headings, prompts, the thing to notice. */
+  strong(s: string): string;
+  /** Dim — secondary detail, defaults, asides. */
+  dim(s: string): string;
+  /** Accent — commands, flags, and file paths the user should copy. */
+  accent(s: string): string;
+}
+
+const PLAIN_FMT: Fmt = { strong: (s) => s, dim: (s) => s, accent: (s) => s };
+
+/**
+ * The IO seam — every command takes an Io so tests can script answers and
+ * capture output without a TTY. Non-interactive sessions (piped, `--yes`,
+ * tests) resolve every prompt to its declared default.
+ */
+export interface Io {
+  readonly interactive: boolean;
+  readonly fmt: Fmt;
+  print(msg?: string): void;
+  ok(msg: string): void;
+  warn(msg: string): void;
+  error(msg: string): void;
+  ask(question: string, fallback?: string): Promise<string>;
+  confirm(question: string, def?: boolean): Promise<boolean>;
+  select<T extends string>(question: string, choices: readonly T[], def: T): Promise<T>;
+  close(): void;
+}
+
+export function consoleIo(interactive: boolean): Io {
+  // NO_COLOR opts out, FORCE_COLOR opts in — otherwise a TTY decides.
+  const color =
+    process.env.NO_COLOR === undefined &&
+    (process.env.FORCE_COLOR !== undefined || stdout.isTTY === true);
+  const style = (f: Parameters<typeof styleText>[0]) => (s: string) =>
+    color ? styleText(f, s) : s;
+  const fmt: Fmt = color
+    ? { strong: style('bold'), dim: style('dim'), accent: style('cyan') }
+    : PLAIN_FMT;
+  const okMark = style('green')(' ✓ ');
+  const warnMark = style('yellow')(' ! ');
+  const errorMark = style('red')(' ✗ ');
+  const rl: Interface | null = interactive
+    ? createInterface({ input: stdin, output: stdout })
+    : null;
+  return {
+    interactive,
+    fmt,
+    print: (msg = '') => stdout.write(msg + '\n'),
+    ok: (msg) => stdout.write(`${okMark} ${msg}\n`),
+    warn: (msg) => stdout.write(`${warnMark} ${msg}\n`),
+    error: (msg) => stderr.write(`${errorMark} ${msg}\n`),
+    async ask(question, fallback = '') {
+      if (!rl) return fallback;
+      const answer = (await rl.question(`${fmt.strong(question)} `)).trim();
+      return answer || fallback;
+    },
+    async confirm(question, def = false) {
+      if (!rl) return def;
+      const hint = fmt.dim(`[${def ? 'Y/n' : 'y/N'}]`);
+      const answer = (await rl.question(`${fmt.strong(question)} ${hint} `))
+        .trim()
+        .toLowerCase();
+      return answer === '' ? def : answer === 'y' || answer === 'yes';
+    },
+    async select(question, choices, def) {
+      if (!rl) return def;
+      stdout.write(fmt.strong(question) + '\n');
+      choices.forEach((c, i) =>
+        stdout.write(
+          `  ${fmt.accent(String(i + 1))}) ${c}${c === def ? fmt.dim(' (default)') : ''}\n`,
+        ),
+      );
+      const answer = (
+        await rl.question(`${fmt.dim(`choose [1-${choices.length}]:`)} `)
+      ).trim();
+      if (answer === '') return def;
+      const pick = choices[Number(answer) - 1] ?? choices.find((c) => c === answer);
+      return pick ?? def;
+    },
+    close: () => rl?.close(),
+  };
+}
+
+/** Test/script driver — canned answers in order, output captured for assertions. */
+export function scriptIo(answers: readonly (string | boolean)[] = []): Io & { output: string[] } {
+  const output: string[] = [];
+  const queue = [...answers];
+  const next = () => queue.shift();
+  const io: Io & { output: string[] } = {
+    interactive: true,
+    fmt: PLAIN_FMT,
+    output,
+    print: (msg = '') => output.push(msg),
+    ok: (msg) => output.push(`ok ${msg}`),
+    warn: (msg) => output.push(`warn ${msg}`),
+    error: (msg) => output.push(`error ${msg}`),
+    async ask(_q, fallback = '') {
+      const a = next();
+      return typeof a === 'string' && a !== '' ? a : fallback;
+    },
+    async confirm(_q, def = false) {
+      const a = next();
+      if (typeof a === 'boolean') return a;
+      if (typeof a === 'string' && a !== '') return a.toLowerCase().startsWith('y');
+      return def;
+    },
+    async select(_q, choices, def) {
+      const a = next();
+      if (typeof a === 'string' && a !== '') {
+        return choices[Number(a) - 1] ?? choices.find((c) => c === a) ?? def;
+      }
+      return def;
+    },
+    close: () => {},
+  };
+  return io;
+}

package/src/parse.ts

@@ -0,0 +1,53 @@
+export interface ParsedArgs {
+  /** Positional args (commands, names). */
+  _: string[];
+  /** `--flag`, `--flag=value`, `--flag value`, `-abc` shorts. */
+  flags: Record<string, string | boolean>;
+}
+
+export function parseArgs(argv: readonly string[]): ParsedArgs {
+  const _: string[] = [];
+  const flags: Record<string, string | boolean> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--') {
+      _.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq !== -1) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+      } else if (i + 1 < argv.length && !argv[i + 1].startsWith('-')) {
+        flags[a.slice(2)] = argv[++i];
+      } else {
+        flags[a.slice(2)] = true;
+      }
+    } else if (a.startsWith('-') && a.length > 1) {
+      for (const ch of a.slice(1)) flags[ch] = true;
+    } else {
+      _.push(a);
+    }
+  }
+  return { _, flags };
+}
+
+export const flag = (args: ParsedArgs, name: string): string | undefined =>
+  typeof args.flags[name] === 'string' ? (args.flags[name] as string) : undefined;
+
+export const hasFlag = (args: ParsedArgs, ...names: string[]): boolean =>
+  names.some((n) => args.flags[n] === true || typeof args.flags[n] === 'string');
+
+/** kebab-case → camelCase (`incidents-api` → `incidentsApi`). */
+export const camel = (name: string): string =>
+  name.replace(/[-_](.)/g, (_m, c: string) => c.toUpperCase());
+
+/** kebab-case → PascalCase (`incidents-api` → `IncidentsApi`). */
+export const pascal = (name: string): string => {
+  const c = camel(name);
+  return c.charAt(0).toUpperCase() + c.slice(1);
+};
+
+/** Validate a generated-file basename — keeps paths inside the target dir. */
+export const validName = (name: string): boolean =>
+  /^[a-z][a-z0-9]*([-_][a-z0-9]+)*$/.test(name);

package/src/project.ts

@@ -0,0 +1,132 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export type Framework =
+  | 'angular'
+  | 'nestjs'
+  | 'nextjs'
+  | 'node'
+  | 'react'
+  | 'solid'
+  | 'svelte'
+  | 'vanilla'
+  | 'vue';
+
+export type Pm = 'npm' | 'pnpm' | 'yarn' | 'bun';
+
+export interface PkgJson {
+  name?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+export interface ProjectInfo {
+  /** Dir containing the nearest package.json, or null outside a project. */
+  root: string | null;
+  pkg: PkgJson | null;
+  framework: Framework;
+  pm: Pm;
+  /** Preferred source dir — `src` when present, else the project root. */
+  srcDir: string;
+}
+
+/** Walk up from `cwd` to the nearest dir containing a package.json. */
+export function findRoot(cwd: string): string | null {
+  let dir = cwd;
+  for (;;) {
+    if (existsSync(join(dir, 'package.json'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export function readPkg(dir: string): PkgJson | null {
+  try {
+    return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')) as PkgJson;
+  } catch {
+    return null;
+  }
+}
+
+const DEPS_OF = (pkg: PkgJson | null): Record<string, string> => ({
+  ...(pkg?.dependencies ?? {}),
+  ...(pkg?.devDependencies ?? {}),
+});
+
+/**
+ * Order is the contract — a nestjs app also depends on express-style libs,
+ * a nextjs app also depends on react. Most specific host wins first.
+ */
+const DETECT: readonly [Framework, readonly string[]][] = [
+  ['nestjs', ['@nestjs/core', '@nestjs/common']],
+  ['nextjs', ['next']],
+  ['angular', ['@angular/core']],
+  ['svelte', ['svelte']],
+  ['solid', ['solid-js']],
+  ['vue', ['vue']],
+  ['react', ['react', 'react-dom']],
+  ['node', ['@atolljs/node', 'express', 'fastify', 'hono', 'koa', '@nestjs/core']],
+];
+
+export function detectFramework(pkg: PkgJson | null): Framework {
+  const deps = DEPS_OF(pkg);
+  for (const [fw, names] of DETECT) {
+    if (names.some((n) => deps[n] !== undefined)) return fw;
+  }
+  return 'vanilla';
+}
+
+export function detectPm(root: string): Pm {
+  if (existsSync(join(root, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (existsSync(join(root, 'yarn.lock'))) return 'yarn';
+  if (existsSync(join(root, 'bun.lockb')) || existsSync(join(root, 'bun.lock'))) return 'bun';
+  return 'npm';
+}
+
+export function detectProject(cwd: string): ProjectInfo {
+  const root = findRoot(cwd);
+  if (!root) {
+    return { root: null, pkg: null, framework: 'vanilla', pm: 'npm', srcDir: cwd };
+  }
+  const pkg = readPkg(root);
+  return {
+    root,
+    pkg,
+    framework: detectFramework(pkg),
+    pm: detectPm(root),
+    srcDir: existsSync(join(root, 'src')) ? join(root, 'src') : root,
+  };
+}
+
+/** The dependency line `init` installs per detected framework (zod is
+ *  part of the public API surface — generated workers declare schemas). */
+export const ATOLL_DEPS: Record<Framework, readonly string[]> = {
+  react: ['@atolljs/core', '@atolljs/react', '@atolljs/react-island', 'zod'],
+  vue: ['@atolljs/core', '@atolljs/vue', '@atolljs/vue-island', 'zod'],
+  solid: ['@atolljs/core', '@atolljs/solidjs', '@atolljs/solid-island', 'zod'],
+  svelte: ['@atolljs/core', '@atolljs/svelte', '@atolljs/svelte-island', 'zod'],
+  angular: ['@atolljs/core', '@atolljs/angular', '@atolljs/angular-island', 'zod'],
+  nextjs: ['@atolljs/core', '@atolljs/nextjs', 'zod'],
+  nestjs: ['@atolljs/core', '@atolljs/nestjs', '@atolljs/node', 'zod'],
+  node: ['@atolljs/core', '@atolljs/node', 'zod'],
+  vanilla: ['@atolljs/core', 'zod'],
+};
+
+export const ISLAND_FRAMEWORKS: readonly Framework[] = [
+  'react',
+  'vue',
+  'solid',
+  'svelte',
+  'angular',
+];
+
+export const pmInstallCmd = (pm: Pm, pkgs: readonly string[]): string =>
+  `${pm} ${pm === 'npm' ? 'install' : 'add'} ${pkgs.join(' ')}`;
+
+/** Which deps from `want` are absent from the project's manifest. */
+export function missingDeps(pkg: PkgJson | null, want: readonly string[]): string[] {
+  const deps = DEPS_OF(pkg);
+  return want.filter((d) => deps[d] === undefined);
+}