@m6d/cortex-cli 0.12.1 → 0.14.0

package/src/commands/new.ts

@@ -2,13 +2,14 @@ import { spawnSync } from "node:child_process";
 import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
-import { Option, type Command } from "@commander-js/extra-typings";
+import type { Command } from "@commander-js/extra-typings";
+import { CORTEX_MANIFEST_ID } from "@cortex/contracts/manifest";
 
 import pkg from "../../package.json";
-import { FEATURE_NAMES, FEATURES, type Feature } from "@/scaffold/features";
-import { scaffoldFiles, type Database } from "@/scaffold/files";
-import { allocatePorts } from "@/scaffold/ports";
-import { askDatabase, askFeatures, askName, intro, log, outro, runSteps } from "@/ui/prompts";
+import { askProvider } from "@/commands/setup";
+import { AGENT_SLUG, manifestIdOf, scaffoldFiles } from "@/scaffold/files";
+import { allocatePorts, type Ports } from "@/scaffold/ports";
+import { askConfirm, askName, intro, log, outro, runSteps } from "@/ui/prompts";
 import * as report from "@/ui/report";
 
 /** npm's rule for an unscoped package name. The name is the directory too. */
@@ -18,55 +19,32 @@ const MAX_NAME = 214;
 /** The two names npm rejects outright, however well-formed they otherwise are. */
 const RESERVED_NAMES = ["node_modules", "favicon.ico"];
 
-export function registerNew(program: Command) {
+export function registerNew(program: Command<[], { verbose?: true }>) {
     const command = program
         .command("new")
         .helpGroup("Project:")
-        .description("Scaffold a new Cortex server")
+        .description("Scaffold a backend, its agent, and Cortex to run it on")
         .argument("[name]", "Directory to create, and the generated package name")
-        .addOption(
-            new Option("--database <type>", "Database the project is configured for")
-                .choices(["postgres", "mssql"] as const)
-                .default("postgres" as const),
-        )
-        // Both halves of every toggle, so a flag can answer its question either
-        // way and `--yes` is not the only way to say "no". Declaring the positive
-        // first leaves the value `undefined` when neither is passed, which is
-        // what marks the question as still unanswered.
-        .option("--attachments", FEATURES.attachments.hint)
-        .option("--no-attachments", "Leave attachments out")
-        .option("--redis", FEATURES.redis.hint)
-        .option("--no-redis", "Leave Redis out")
-        .option("--auth", FEATURES.auth.hint)
-        .option("--no-auth", "Leave auth out")
-        .option("--knowledge", FEATURES.knowledge.hint)
-        .option("--no-knowledge", "Leave the knowledge graph out")
-        .option("--control-center", FEATURES.controlCenter.hint)
-        .option("--no-control-center", "Leave the Control Center out")
+        .option("--datasets", "Serve an example table as a dataset host")
+        // Both halves of the toggle, so the flag can answer its question either
+        // way and `--yes` is not the only way to say "yes". Declaring the
+        // positive first leaves the value `undefined` when neither is passed,
+        // which is what marks the question as still unanswered.
+        .option("--setup", `Set up the ${AGENT_SLUG} agent on the first bun run dev`)
+        .option("--no-setup", "Leave Cortex empty; you register the backend yourself")
         .option("--yes", "Accept the defaults instead of asking");
 
     command.action(async function (name, options) {
-        // The globals live on the root command, which reaches this file untyped —
-        // `Command` here is the parameter type, not cli.ts's inferred one.
-        const { verbose = false } = program.opts() as { verbose?: boolean };
-
-        await scaffold(name, {
-            ...options,
-            verbose,
-            databasePassed: command.getOptionValueSource("database") !== "default",
-        });
+        const { verbose = false } = program.opts();
+
+        await scaffold(name, { ...options, verbose });
     });
 }
 
-type Options = {
-    database: Database;
-    yes?: boolean;
-    verbose: boolean;
-    databasePassed: boolean;
-} & Partial<Record<Feature, boolean>>;
+type Options = { datasets?: true; setup?: boolean; yes?: true; verbose: boolean };
 
 async function scaffold(name: string | undefined, options: Options) {
-    const { verbose, databasePassed } = options;
+    const { verbose } = options;
 
     // No TTY ⇒ never prompt and behave as `--yes`. On Bun a piped stdin reports
     // `undefined` rather than `false`, which is why this compares against `true`.
@@ -77,6 +55,7 @@ async function scaffold(name: string | undefined, options: Options) {
     // A name that came from a flag is checked before anything prints; one that
     // is prompted for is checked by the prompt, which can ask again.
     if (name !== undefined && !isValidName(name)) failInvalidName(name);
+    if (name !== undefined && manifestIdOf(name) === CORTEX_MANIFEST_ID) failCortexId(name);
     if (name !== undefined && isTaken(resolve(process.cwd(), name))) failTaken(name);
 
     const started = Date.now();
@@ -84,15 +63,15 @@ async function scaffold(name: string | undefined, options: Options) {
 
     const project = name ?? (await askName(checkName)).trim();
 
-    const database = interactive && !databasePassed ? await askDatabase() : options.database;
-    const features = await chooseFeatures(options, interactive);
+    const datasets = options.datasets === true;
+    const { setup, provider } = await askSetup(options.setup, interactive);
 
     const target = resolve(process.cwd(), project);
 
-    // Allocated here rather than inside the generators, which stay pure: picking a
+    // Drawn here rather than inside the generators, which stay pure: picking a
     // port means probing the machine for a free one.
     const ports = allocatePorts();
-    const files = scaffoldFiles(project, database, features, ports);
+    const files = scaffoldFiles({ name: project, datasets, setup, ports, env: provider?.env });
     let failedInstall: string | undefined;
 
     await runSteps([
@@ -102,11 +81,18 @@ async function scaffold(name: string | undefined, options: Options) {
                 for (const [path, contents] of Object.entries(files)) {
                     const file = join(target, path);
                     mkdirSync(dirname(file), { recursive: true });
-                    writeFileSync(file, contents);
+                    // .env holds the provider's key before setup.ts adds the rest.
+                    writeFileSync(file, contents, { mode: path === ".env" ? 0o600 : 0o644 });
                 }
 
-                const summary = [database, ...features, "model"].join(" · ");
-                return `Wrote ${Object.keys(files).length} files to ./${project}\n${summary}`;
+                const summary = [
+                    "server",
+                    ...(datasets ? ["dataset host"] : []),
+                    "manifest",
+                    "Cortex",
+                    ...(setup ? ["first-run setup"] : []),
+                ];
+                return `Wrote ${Object.keys(files).length} files to ./${project}\n${summary.join(" · ")}`;
             },
         },
         {
@@ -152,7 +138,25 @@ async function scaffold(name: string | undefined, options: Options) {
     if (failedInstall !== undefined) warnInstall(project, failedInstall, verbose);
 
     outro(`Done in ${seconds(started)}`);
-    process.stdout.write(nextSteps(project, features, files));
+    process.stdout.write(nextSteps(project, ports, setup, provider !== undefined));
+}
+
+/**
+ * Whether the first `bun run dev` sets up the agent, and the model provider
+ * it runs on. A flag settles the first question; otherwise it is asked, or
+ * under `--yes` answered yes. The provider has no default, so only a terminal
+ * asks for one; without it, setup registers the server and stops.
+ */
+async function askSetup(flag: boolean | undefined, interactive: boolean) {
+    const setup =
+        flag ??
+        (!interactive ||
+            (await askConfirm(
+                `Set up the ${AGENT_SLUG} agent when you first run bun run dev?`,
+                true,
+            )));
+    const provider = setup && interactive ? await askProvider() : undefined;
+    return { setup, provider };
 }
 
 /**
@@ -172,39 +176,20 @@ function warnInstall(project: string, output: string, verbose: boolean) {
     );
 }
 
-function nextSteps(project: string, features: Feature[], files: ReturnType<typeof scaffoldFiles>) {
-    const keys = [
-        "CORTEX_DATABASE_URL",
-        "CORTEX_MODEL_*",
-        ...features.map((feature) => FEATURES[feature].secrets).filter((key) => key !== undefined),
-    ];
-
-    return (
-        `\nNext steps:\n\n` +
-        step(`cd ${project}`) +
-        step("edit .env", `fill in ${keys.length === 2 ? keys.join(" and ") : keys.join(", ")}`) +
-        (files["docker-compose.yml"] === undefined ? "" : step("docker compose up -d")) +
-        // The `port` the generated cortex.config.ts sets, which is the server's
-        // own default. Service ports move at scaffold time; this one does not.
-        step("bun run dev", "→ http://localhost:3331") +
-        `\n`
-    );
-}
-
-/**
- * One multi-select for the whole catalogue, minus whatever the flags already
- * settled: a passed flag suppresses its question, the rest are still asked.
- */
-async function chooseFeatures(options: Options, interactive: boolean) {
-    const chosen = new Set(FEATURE_NAMES.filter((feature) => options[feature] === true));
-    const undecided = FEATURE_NAMES.filter((feature) => options[feature] === undefined);
-
-    if (interactive && undecided.length > 0) {
-        for (const feature of await askFeatures(undecided)) chosen.add(feature);
-    }
-
-    // Catalogue order, not the order the flags or the checkboxes came in.
-    return FEATURE_NAMES.filter((feature) => chosen.has(feature));
+/** What the first `bun run dev` sets up: the agent, the server alone (no model yet), or nothing. */
+function nextSteps(project: string, ports: Ports, setup: boolean, provider: boolean) {
+    const runs = {
+        agent: step("bun run dev", `→ sets up ${AGENT_SLUG}, then prints where to chat`),
+        server:
+            step("bun run dev", "→ registers the server") +
+            step("bun cortex setup", "adds a model provider, then applies"),
+        none:
+            step("bun run dev", `→ Cortex at http://localhost:${ports.cortex}`) +
+            step("README.md", "register the server, then bun cortex apply"),
+    };
+    const run = setup ? (provider ? runs.agent : runs.server) : runs.none;
+
+    return `\nNext steps:\n\n${step(`cd ${project}`)}${run}\n`;
 }
 
 async function install(cwd: string) {
@@ -245,11 +230,14 @@ function isValidName(name: string) {
     return name.length <= MAX_NAME && VALID_NAME.test(name) && !RESERVED_NAMES.includes(name);
 }
 
-/** The prompt's rules, which are the flag path's two failures asked one at a time. */
+/** The prompt's rules, which are the flag path's failures asked one at a time. */
 function checkName(candidate: string) {
     // One line each: clack prints them inside the prompt, which will not wrap.
     if (RESERVED_NAMES.includes(candidate)) return `npm does not allow the name ${candidate}.`;
     if (!isValidName(candidate)) return "Lowercase letters, digits, and . _ - only.";
+    if (manifestIdOf(candidate) === CORTEX_MANIFEST_ID) {
+        return `The manifest would take Cortex's own id, ${CORTEX_MANIFEST_ID}.`;
+    }
     if (isTaken(resolve(process.cwd(), candidate))) {
         return `./${candidate} already exists and is not an empty directory.`;
     }
@@ -307,6 +295,17 @@ function missingName(): never {
     });
 }
 
+/** The manifest takes its id from the name, and Cortex refuses any manifest under its own. */
+function failCortexId(name: string): never {
+    report.fail({
+        what: `"${name}" would give the manifest Cortex's own id, ${CORTEX_MANIFEST_ID}`,
+        blocks: [
+            "cortex.manifest.ts takes its id from the project name, and Cortex keeps that\nid for its own manifest. Pick another name:",
+            `  cortex new ${CORTEX_MANIFEST_ID}-app`,
+        ],
+    });
+}
+
 function failTaken(name: string): never {
     report.fail({
         what: `./${name} already exists and is not an empty directory.`,