@m6d/cortex-cli 1.0.0

package/src/ui/report.ts

@@ -0,0 +1,102 @@
+/**
+ * The output grammar, shared by every command that runs against a project.
+ * Layout is fixed by `docs/prototypes/cli-output.md`; this file is the only
+ * place that knows the box characters.
+ */
+
+import { inspect } from "node:util";
+
+import pc from "picocolors";
+
+const BAR = pc.gray("│");
+
+function write(stream: NodeJS.WriteStream, lines: string[]) {
+    stream.write(`${lines.join("\n")}\n`);
+}
+
+/** Every block inside an error sits three spaces in, commands two further. */
+function indent(block: string) {
+    return block
+        .split("\n")
+        .map((line) => `   ${line}`)
+        .join("\n");
+}
+
+function describe(error: unknown) {
+    if (!(error instanceof Error)) return String(error);
+    return `${error.name}: ${error.message}`.split("\n")[0] ?? error.name;
+}
+
+// An error hugs whatever the run last printed, so it needs to know whether
+// anything opened the box above it.
+let open = false;
+
+/** `┌  cortex graph seed` — opens a run. */
+/** `1 node` / `3 nodes` — every count the box prints goes through this. */
+export function plural(count: number, noun: string) {
+    return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+
+export function header(title: string) {
+    open = true;
+    write(process.stdout, ["", `${pc.gray("┌")}  ${title}`, BAR]);
+}
+
+/**
+ * A resolved input. These double as progress: whatever was printed last says how
+ * far the run got, which is most of the diagnosis when the next step fails.
+ */
+export function input(label: string, value: string) {
+    write(process.stdout, [`${pc.green("◇")}  ${label.padEnd(9)}  ${value}`]);
+}
+
+export function blank() {
+    write(process.stdout, [BAR]);
+}
+
+/**
+ * `│  updated   leaves/listLeaves.endpoint.ts` — a row in the body. An empty
+ * label indents to the same gutter, for the second line a finding gets. `width`
+ * is the label column: findings fit in 10, domain names need 14.
+ */
+export function row(label: string, text: string, width = 10) {
+    write(process.stdout, [`${BAR}  ${label.padEnd(width - 2)}  ${text}`]);
+}
+
+/** `└  87 nodes · 124 edges  (6.2s)` — closes a run. */
+export function footer(text: string) {
+    write(process.stdout, [`${pc.gray("└")}  ${text}`, ""]);
+}
+
+/** A paragraph below the box, for the one thing the reader has to act on. */
+export function note(text: string) {
+    write(process.stdout, [text, ""]);
+}
+
+/**
+ * One error grammar: what happened → why → a runnable command. One line of the
+ * underlying error is kept — it is what gets pasted into a search — and the rest
+ * waits behind `--verbose`.
+ */
+export function fail(options: {
+    what: string;
+    blocks?: string[];
+    error?: unknown;
+    verbose?: boolean;
+}): never {
+    const { what, blocks = [], error, verbose = false } = options;
+    const parts = [`${pc.red("■")}  ${what}`];
+
+    if (error !== undefined) parts.push(indent(describe(error)));
+    parts.push(...blocks.map(indent));
+    if (error !== undefined) {
+        // `inspect` rather than `error.stack`: a Bun `fetch` failure carries no
+        // stack at all, and its `code` is the useful part.
+        parts.push(
+            indent(verbose ? inspect(error) : "Run with --verbose for the full stack trace."),
+        );
+    }
+
+    write(process.stderr, open ? [parts.join("\n\n"), ""] : ["", parts.join("\n\n"), ""]);
+    process.exit(1);
+}

package/tsconfig.json

@@ -0,0 +1,45 @@
+{
+    "compilerOptions": {
+        // Environment setup & latest features
+        "lib": ["ESNext"],
+        // Named explicitly: auto-inclusion of @types/* is an editor-dependent
+        // heuristic, and `Bun`/`Response` come from here. See @cortex/contracts'
+        // tsconfig for the same fix.
+        "types": ["bun"],
+        "target": "ESNext",
+        "module": "Preserve",
+        "moduleDetection": "force",
+        "baseUrl": ".",
+
+        // Bundler mode
+        "moduleResolution": "bundler",
+        "verbatimModuleSyntax": true,
+        "resolveJsonModule": true,
+        "noEmit": true,
+        "paths": {
+            // The graph contract is @cortex/contracts, a private workspace package
+            // that never publishes, so the CLI carries its own copy: `prepack`
+            // vendors it into src/contracts, where the first candidate finds it in
+            // the published tarball. Inside the repo that copy doesn't exist and
+            // resolution falls through to the workspace source.
+            "@cortex/contracts/*": ["./src/contracts/*", "../../internal/contracts/*"],
+            // Internal-only, and the reason this file ships in package.json `files`:
+            // the CLI runs as raw TypeScript from inside node_modules, so Bun has to
+            // read this config to resolve `@/`.
+            "@/*": ["./src/*"]
+        },
+
+        // Best practices
+        "strict": true,
+        "skipLibCheck": true,
+        "noFallthroughCasesInSwitch": true,
+        "noUncheckedIndexedAccess": true,
+        "noImplicitOverride": true,
+
+        // Some stricter flags (disabled by default)
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "noPropertyAccessFromIndexSignature": false
+    },
+    "include": ["src/**/*.ts"]
+}