rastack 0.0.22 → 0.0.23

package/src/compile/index.ts

@@ -1,12 +1,15 @@
 import * as fs from "fs";
 import * as path from "path";
 import { analyze } from "./analyze";
+import { analyzeEntities, detectCycles, EntityDiagnostic } from "./entities";
 import { buildManifest, manifestToJson } from "./manifest";
 import { Manifest, ResourceModel } from "./model";
 import { buildOpenApi, openApiToJson } from "./openapi";
 import { createProgram } from "./program";
 
 export { analyze } from "./analyze";
+export { analyzeEntities, detectCycles } from "./entities";
+export type { EntityAnalysis, EntityDiagnostic } from "./entities";
 export { buildManifest } from "./manifest";
 export { buildOpenApi } from "./openapi";
 export * from "./model";
@@ -15,6 +18,7 @@ export interface CompileResult {
   manifest: Manifest;
   openapi: any;
   files: string[];
+  diagnostics: EntityDiagnostic[];
 }
 
 /** Directories never worth walking for resource definitions. */
@@ -22,19 +26,20 @@ const IGNORE_DIRS = new Set([
   "node_modules",
   ".git",
   ".expo",
-  ".rad",
+  ".rad", // legacy output dir
+  ".rastack",
   "dist",
   "web-build",
 ]);
 
 /**
- * Every `.ts` resource file under a directory (recursively), or an explicit
- * file. Recursion is what lets resource definitions live **co-located with the
- * pages that consume them** — e.g. `app/airports/_schema.rad.ts` beside
- * `app/airports/index.tsx` — instead of in one top-level `resources/` folder.
- * `.tsx` route components and `.d.ts` files are skipped; only files with a
- * `resource(...)` call contribute to the manifest, so co-located helpers are
- * harmless.
+ * Every `.ts`/`.tsx` source file under a directory (recursively), or an
+ * explicit file. Recursion is what lets resource definitions live **co-located
+ * with the pages that consume them** — e.g. `app/airports/_schema.rastack.ts`
+ * beside `app/airports/index.tsx` — instead of in one top-level `resources/`
+ * folder. `.tsx` files carry no `resource(...)` definitions but are scanned
+ * for the typed hook calls (`useEntityList<Airport>(…)`) that root the
+ * interface-driven entity graph; co-located helpers are harmless.
  */
 export function resolveResourceFiles(input: string): string[] {
   const stat = fs.existsSync(input) ? fs.statSync(input) : undefined;
@@ -45,7 +50,7 @@ export function resolveResourceFiles(input: string): string[] {
       for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         if (entry.isDirectory()) {
           if (!IGNORE_DIRS.has(entry.name)) walk(path.join(dir, entry.name));
-        } else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+        } else if (/\.tsx?$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
           files.push(path.resolve(dir, entry.name));
         }
       }
@@ -56,26 +61,63 @@ export function resolveResourceFiles(input: string): string[] {
   throw new Error(`No such resources path: ${input}`);
 }
 
-/** Analyse resource definitions into the canonical model (no file output). */
-export function analyzeResources(input: string): ResourceModel[] {
+export interface ProjectAnalysis {
+  resources: ResourceModel[];
+  diagnostics: EntityDiagnostic[];
+}
+
+/**
+ * Analyse a project into the canonical model: explicit `resource()` DSL
+ * definitions plus resources inferred from hook-rooted TypeScript interfaces.
+ * When both surfaces define the same `app.model`, the explicit DSL definition
+ * wins — hook usage of a generated `IAirport` interface resolves back onto the
+ * authored resource instead of creating a duplicate. Cycle detection runs over
+ * the merged FK graph.
+ */
+export function analyzeProject(input: string): ProjectAnalysis {
   const files = resolveResourceFiles(input);
   const program = createProgram(files);
-  return analyze(program, files);
+
+  const fromDsl = analyze(program, files);
+  const fromInterfaces = analyzeEntities(program, files);
+
+  const defined = new Set(fromDsl.map((r) => `${r.app}.${r.model}`));
+  const resources = [
+    ...fromDsl,
+    ...fromInterfaces.resources.filter((r) => !defined.has(`${r.app}.${r.model}`)),
+  ];
+  resources.sort((a, b) =>
+    a.app === b.app ? a.model.localeCompare(b.model) : a.app.localeCompare(b.app),
+  );
+
+  return {
+    resources,
+    diagnostics: [...fromInterfaces.diagnostics, ...detectCycles(resources)],
+  };
+}
+
+/** Analyse resource definitions into the canonical model (no file output). */
+export function analyzeResources(input: string): ResourceModel[] {
+  return analyzeProject(input).resources;
 }
 
 /** Compile resource definitions to a manifest + OpenAPI, writing both to disk. */
 export function compile(input: string, outDir: string): CompileResult {
-  const resources = analyzeResources(input);
+  const { resources, diagnostics } = analyzeProject(input);
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  if (errors.length) {
+    throw new Error(errors.map((e) => e.message).join("\n"));
+  }
   const manifest = buildManifest(resources);
   const openapi = buildOpenApi(resources);
 
   fs.mkdirSync(outDir, { recursive: true });
-  const manifestPath = path.join(outDir, "schema.rad.json");
+  const manifestPath = path.join(outDir, "schema.rastack.json");
   const openapiPath = path.join(outDir, "openapi.json");
   fs.writeFileSync(manifestPath, manifestToJson(manifest), { flag: "w" });
   fs.writeFileSync(openapiPath, openApiToJson(openapi), { flag: "w" });
 
-  return { manifest, openapi, files: [manifestPath, openapiPath] };
+  return { manifest, openapi, files: [manifestPath, openapiPath], diagnostics };
 }
 
 // -- introspection (replaces `manage.py rastack check|list|urls`) -----------

package/src/compile/model.ts

@@ -1,6 +1,6 @@
 /**
  * The canonical, backend-agnostic data model produced by the compiler. This is
- * what `schema.rad.json` serializes and what both the OpenAPI emitter and the
+ * what `schema.rastack.json` serializes and what both the OpenAPI emitter and the
  * Rust API consume.
  */
 
@@ -52,7 +52,7 @@ export interface AdminModel {
 }
 
 /**
- * Row-level access control, enforced by `rad-api-core` on every surface.
+ * Row-level access control, enforced by `rastack-api-core` on every surface.
  * `ownerField` names the field stamped with the authenticated subject;
  * `scope: "owner"` places the table under a per-identity warehouse prefix
  * (`tenants/{sub}/…`) so object-storage IAM can fence data per user.

package/src/compile/program.ts

@@ -3,7 +3,8 @@ import * as ts from "typescript";
 
 /**
  * Build a `ts.Program` (and thus a `TypeChecker`) over a set of resource
- * definition files. The DSL package (`rad-tools/define`) is mapped to the
+ * definition files. The authoring subpaths (`rastack/define` for the DSL,
+ * `rastack/types` for the `DbConfig` column brands) are mapped to the
  * in-tree/installed sources via `paths` so both the shipped package name and
  * the local demo/tests resolve without extra linking.
  */
@@ -18,10 +19,14 @@ export function createProgram(fileNames: string[]): ts.Program {
     skipLibCheck: true,
     esModuleInterop: true,
     noEmit: true,
+    // `.tsx` app files are scanned for the typed hook calls that root the
+    // interface-driven entity graph.
+    jsx: ts.JsxEmit.ReactJSX,
     baseUrl: process.cwd(),
     paths: {
-      "rad-tools/define": [defineDir],
-      "rad-tools/define/*": [defineDir + "/*"],
+      "rastack/define": [defineDir],
+      "rastack/define/*": [defineDir + "/*"],
+      "rastack/types": [path.join(defineDir, "db")],
     },
   };
 

package/src/csv-schema.ts

@@ -47,7 +47,7 @@ const DEFAULT_PII_PATTERNS = [
 ];
 
 function loadPiiConfig(repoRoot: string): PiiConfig {
-  const configPath = path.join(repoRoot, ".rad", "pii-patterns.yml");
+  const configPath = path.join(repoRoot, ".rastack", "pii-patterns.yml");
   if (!fs.existsSync(configPath)) {
     return { patterns: DEFAULT_PII_PATTERNS, luhn_check: true, require_policy: true };
   }

package/src/define/db.ts

@@ -0,0 +1,64 @@
+/**
+ * Type-level column configuration for interface-driven entities.
+ *
+ * Interface entities are plain TypeScript, so their column constraints are
+ * expressed *in the type system*: intersect a property type with one or more
+ * {@link DbConfig} brands and the compiler reads the configuration straight
+ * off the type — the same way it reads foreign keys.
+ *
+ * ```ts
+ * import { Default, Int, MaxLength, PrimaryKey, Unique, UUID } from "rastack/types";
+ *
+ * export interface Passenger {
+ *   id: UUID & PrimaryKey;
+ *   seat: string & MaxLength<4> & Unique;
+ *   age: Int;                          // number maps to float; Int refines it
+ *   status: string & Default<"active">;
+ * }
+ * ```
+ *
+ * Recurring configurations can extend {@link DbConfig} once and be reused:
+ *
+ * ```ts
+ * interface Registration extends DbConfig<{ maxLength: 10; unique: true }> {}
+ *
+ * export interface Aircraft {
+ *   registration: string & Registration;
+ * }
+ * ```
+ *
+ * The brands are "flavors", not hard brands: the phantom `__rastackDb` property is
+ * optional and never exists at runtime, so a plain `"3F"` stays assignable to
+ * `string & MaxLength<4> & Unique` — no casts anywhere in app code.
+ */
+
+/**
+ * The phantom carrier every constraint type extends. `C` holds the column
+ * configuration as literal types; the compiler recovers it from the `__rastackDb`
+ * property of the intersected field type.
+ */
+export interface DbConfig<C = unknown> {
+  readonly __rastackDb?: C;
+}
+
+/** The column value must be unique. */
+export interface Unique extends DbConfig<{ unique: true }> {}
+
+/** The column is the primary key. */
+export interface PrimaryKey extends DbConfig<{ primaryKey: true }> {}
+
+/** Maximum length for string columns: `string & MaxLength<120>`. */
+export interface MaxLength<N extends number> extends DbConfig<{ maxLength: N }> {}
+
+/** Server-side default value: `string & Default<"scheduled">`, `number & Default<0>`. */
+export interface Default<V extends string | number | boolean>
+  extends DbConfig<{ default: V }> {}
+
+/** An integer column — a bare `number` property maps to `float`. */
+export type Int = number & DbConfig<{ int: true }>;
+
+/** A UUID column, stored as a string. */
+export type UUID = string & DbConfig<{ uuid: true }>;
+
+/** A datetime column authored as a string (a `Date` property maps directly). */
+export type DateTimeString = string & DbConfig<{ datetime: true }>;

package/src/define/index.ts

@@ -1,5 +1,5 @@
 /**
- * rad-tools authoring DSL — the TypeScript-first source of truth.
+ * rastack authoring DSL — the TypeScript-first source of truth.
  *
  * Resources are authored as plain TypeScript. The compiler
  * (`tools/src/compile`) reads these definitions and, crucially, **infers
@@ -9,7 +9,7 @@
  * `Ref`'s string-literal type arguments.
  *
  * ```ts
- * import { resource, s } from "rad-tools/define";
+ * import { resource, s } from "rastack/define";
  *
  * export const Airport = resource("airports", "airport", {
  *   code: s.string({ maxLength: 3, unique: true }),
@@ -23,9 +23,9 @@
  * ```
  */
 
-/** A scalar field. The literal `__radScalar` type is what the compiler reads. */
+/** A scalar field. The literal `__rastackScalar` type is what the compiler reads. */
 export interface Scalar<T extends string> {
-  readonly __radScalar: T;
+  readonly __rastackScalar: T;
 }
 
 /**
@@ -33,7 +33,7 @@ export interface Scalar<T extends string> {
  * arguments so the compiler can recover the relation target purely from types.
  */
 export interface Ref<App extends string, Model extends string> {
-  readonly __radRef: true;
+  readonly __rastackRef: true;
   readonly __app: App;
   readonly __model: Model;
 }
@@ -72,22 +72,22 @@ export interface DateOptions {
  */
 export const s = {
   string(_opts?: StringOptions): Scalar<"string"> {
-    return { __radScalar: "string" } as Scalar<"string">;
+    return { __rastackScalar: "string" } as Scalar<"string">;
   },
   int(_opts?: NumberOptions): Scalar<"int"> {
-    return { __radScalar: "int" } as Scalar<"int">;
+    return { __rastackScalar: "int" } as Scalar<"int">;
   },
   float(_opts?: NumberOptions): Scalar<"float"> {
-    return { __radScalar: "float" } as Scalar<"float">;
+    return { __rastackScalar: "float" } as Scalar<"float">;
   },
   bool(_opts?: BoolOptions): Scalar<"bool"> {
-    return { __radScalar: "bool" } as Scalar<"bool">;
+    return { __rastackScalar: "bool" } as Scalar<"bool">;
   },
   datetime(_opts?: DateOptions): Scalar<"datetime"> {
-    return { __radScalar: "datetime" } as Scalar<"datetime">;
+    return { __rastackScalar: "datetime" } as Scalar<"datetime">;
   },
   uuid(_opts?: StringOptions): Scalar<"uuid"> {
-    return { __radScalar: "uuid" } as Scalar<"uuid">;
+    return { __rastackScalar: "uuid" } as Scalar<"uuid">;
   },
   /**
    * A foreign key. The target is `() => SomeResource`; the compiler resolves
@@ -97,7 +97,7 @@ export const s = {
   ref<A extends string, M extends string>(
     _thunk: () => ResourceType<A, M, any>,
   ): Ref<A, M> {
-    return { __radRef: true } as Ref<A, M>;
+    return { __rastackRef: true } as Ref<A, M>;
   },
 };
 
@@ -113,8 +113,8 @@ export interface SyncOptions {
 }
 
 /**
- * Row-level access control. Enforced by `rad-api-core`, so the rules are
- * identical on the server (Lambda / `rad serve`) and in the in-browser WASM
+ * Row-level access control. Enforced by `rastack-api-core`, so the rules are
+ * identical on the server (Lambda / `rastack serve`) and in the in-browser WASM
  * engine.
  *
  * - `ownerField` — the field that records the owning identity (the verified
@@ -152,7 +152,7 @@ export interface ResourceOptions {
  * arguments so a {@link Ref} to this resource carries a recoverable target.
  */
 export interface ResourceType<App extends string, Model extends string, F> {
-  readonly __rad: "resource";
+  readonly __rastack: "resource";
   readonly __app: App;
   readonly __model: Model;
   readonly app: App;
@@ -173,7 +173,7 @@ export function resource<
   options: ResourceOptions = {},
 ): ResourceType<App, Model, F> {
   return {
-    __rad: "resource",
+    __rastack: "resource",
     __app: app,
     __model: model,
     app,

package/src/index.ts

@@ -9,7 +9,7 @@ const schemaOnly = args.includes("--schema-only");
 
 const currentDir = process.cwd(); // Get the current working directory
 const kodeDir = path.join(currentDir, ".kode");
-const configFile = path.join(kodeDir, "generate-rad-sdk.json");
+const configFile = path.join(kodeDir, "generate-rastack-sdk.json");
 let config: any = {};
 
 // Create the .kode directory if it doesn't exist

package/src/{rad-compile.ts → rastack-compile.ts}

@@ -1,19 +1,25 @@
 #!/usr/bin/env node
 
 /**
- * `rad compile | check | list | urls` — the TypeScript-first replacement for the
+ * `rastack compile | check | list | urls` — the TypeScript-first replacement for the
  * old Django `manage.py rastack` command.
  *
- *   rad compile [resourcesDir] [outDir]   defs → schema.rad.json + openapi.json
- *   rad check   [resourcesDir]            validate the resource graph (exit != 0 on error)
- *   rad list    [resourcesDir]            print every resource + its fields/relations
- *   rad urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
+ *   rastack compile [resourcesDir] [outDir]   defs → schema.rastack.json + openapi.json
+ *   rastack check   [resourcesDir]            validate the resource graph (exit != 0 on error)
+ *   rastack list    [resourcesDir]            print every resource + its fields/relations
+ *   rastack urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
  */
 
-import { analyzeResources, collisions, compile, urlsFor } from "./compile";
+import {
+  analyzeProject,
+  analyzeResources,
+  collisions,
+  compile,
+  urlsFor,
+} from "./compile";
 
 const DEFAULT_RESOURCES = "resources";
-const DEFAULT_OUT = ".rad";
+const DEFAULT_OUT = ".rastack";
 
 function main(argv: string[]): void {
   const [sub, ...rest] = argv;
@@ -23,14 +29,25 @@ function main(argv: string[]): void {
       const resourcesDir = rest[0] || DEFAULT_RESOURCES;
       const outDir = rest[1] || DEFAULT_OUT;
       const result = compile(resourcesDir, outDir);
+      for (const d of result.diagnostics) console.warn(`  ⚠ ${d.message}`);
       console.log(
         `✓ compiled ${result.manifest.resources.length} resource(s) → ${result.files.join(", ")}`,
       );
       break;
     }
     case "check": {
-      const resources = analyzeResources(rest[0] || DEFAULT_RESOURCES);
-      const errors = collisions(resources);
+      const { resources, diagnostics } = analyzeProject(
+        rest[0] || DEFAULT_RESOURCES,
+      );
+      const errors = [
+        ...collisions(resources),
+        ...diagnostics
+          .filter((d) => d.severity === "error")
+          .map((d) => d.message),
+      ];
+      for (const d of diagnostics.filter((d) => d.severity === "warning")) {
+        console.warn(`  ⚠ ${d.message}`);
+      }
       if (errors.length) {
         for (const e of errors) console.error(`  ✗ ${e}`);
         console.error(`${errors.length} error(s) found.`);
@@ -74,10 +91,10 @@ function main(argv: string[]): void {
       console.error(
         `Unknown compile subcommand: "${sub}"\n\n` +
           `Usage:\n` +
-          `  rad compile [resourcesDir] [outDir]\n` +
-          `  rad check   [resourcesDir]\n` +
-          `  rad list    [resourcesDir]\n` +
-          `  rad urls    [resourcesDir]\n`,
+          `  rastack compile [resourcesDir] [outDir]\n` +
+          `  rastack check   [resourcesDir]\n` +
+          `  rastack list    [resourcesDir]\n` +
+          `  rastack urls    [resourcesDir]\n`,
       );
       process.exit(1);
   }

package/src/{rad-wasm-build.ts → rastack-wasm-build.ts}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 /**
- * `rad wasm` — compile the Rust API to WebAssembly for in-browser local dev.
+ * `rastack wasm` — compile the Rust API to WebAssembly for in-browser local dev.
  *
  * Pipeline:
  *   1. cargo build -p rad-wasm --release --target wasm32-unknown-unknown
- *   2. wasm-bindgen --target web  → stack/wasm/rad_wasm.js + rad_wasm_bg.wasm
+ *   2. wasm-bindgen --target web  → stack/wasm/rastack_wasm.js + rastack_wasm_bg.wasm
  *   3. wasm-opt -Oz (if available) to shrink the binary
  *
  * The generated bundle is what `<RAStackProvider mode="local">` loads. Prereqs:
@@ -25,7 +25,7 @@ const wasmPath = path.join(
   "target",
   "wasm32-unknown-unknown",
   "release",
-  "rad_wasm.wasm",
+  "rastack_wasm.wasm",
 );
 
 function run(cmd: string, args: string[], cwd = repoRoot): void {
@@ -77,7 +77,7 @@ run("wasm-bindgen", [
   "--out-dir",
   outDir,
   "--out-name",
-  "rad_wasm",
+  "rastack_wasm",
   wasmPath,
 ]);
 
@@ -90,13 +90,13 @@ fs.writeFileSync(
 
 if (has("wasm-opt")) {
   console.log("→ wasm-opt -Oz");
-  const bg = path.join(outDir, "rad_wasm_bg.wasm");
+  const bg = path.join(outDir, "rastack_wasm_bg.wasm");
   run("wasm-opt", ["-Oz", "-o", bg, bg]);
 } else {
   console.log("· wasm-opt not found — skipping size optimisation (optional)");
 }
 
-const size = fs.statSync(path.join(outDir, "rad_wasm_bg.wasm")).size;
+const size = fs.statSync(path.join(outDir, "rastack_wasm_bg.wasm")).size;
 console.log(
   `✓ wasm engine built: stack/wasm/ (${(size / 1024).toFixed(0)} KB)`,
 );

package/src/{rad.ts → rastack.ts}

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 
 /**
- * rad — unified CLI for React API Stack
+ * rastack — unified CLI for React API Stack
  *
  * Commands:
- *   rad compile [resourcesDir] [outDir]     TypeScript resources → schema.rad.json + openapi.json
- *   rad check   [resourcesDir]              Validate the resource graph
- *   rad list    [resourcesDir]              Print resources, fields and relations
- *   rad urls    [resourcesDir]              Print the generated /api/{app}/v1/{model}/ routes
- *   rad generate [--schema-only]            Generate typed hooks from OpenAPI
- *   rad serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
- *   rad admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
- *   rad wasm                                Compile the API to WebAssembly (in-browser local dev)
- *   rad scan   [files...] [--fail-on-pii]   Scan CSVs for PII and schema info
- *   rad seed   [--env dev] [--source gs://] Load CSVs into Iceberg namespace
+ *   rastack compile [resourcesDir] [outDir]     TypeScript resources → schema.rastack.json + openapi.json
+ *   rastack check   [resourcesDir]              Validate the resource graph
+ *   rastack list    [resourcesDir]              Print resources, fields and relations
+ *   rastack urls    [resourcesDir]              Print the generated /api/{app}/v1/{model}/ routes
+ *   rastack generate [--schema-only]            Generate typed hooks from OpenAPI
+ *   rastack serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
+ *   rastack admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
+ *   rastack wasm                                Compile the API to WebAssembly (in-browser local dev)
+ *   rastack scan   [files...] [--fail-on-pii]   Scan CSVs for PII and schema info
+ *   rastack seed   [--env dev] [--source gs://] Load CSVs into Iceberg namespace
  */
 
 import { execSync, spawnSync } from "child_process";
@@ -22,7 +22,7 @@ import path from "path";
 const [command, ...rest] = process.argv.slice(2);
 
 function run(script: string, args: string[] = rest) {
-  // `rad` is a local developer CLI: `script` is a fixed internal dist filename
+  // `rastack` is a local developer CLI: `script` is a fixed internal dist filename
   // and `args` come from the developer's own shell (process.argv), not from an
   // untrusted network request — there is no command-injection surface here.
   // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
@@ -36,8 +36,8 @@ function run(script: string, args: string[] = rest) {
 function runRust(subcommand: string) {
   const repoRoot = path.resolve(__dirname, "..", "..");
   const binary =
-    process.env.RAD_SERVER_BIN ||
-    path.join(repoRoot, "rust", "target", "release", "rad-server");
+    process.env.RASTACK_SERVER_BIN ||
+    path.join(repoRoot, "rust", "target", "release", "rastack-server");
   // Runs the locally-built Rust server binary with a fixed internal subcommand
   // ("serve"/"admin"); `rest` is the developer's own CLI args, not untrusted
   // input — no command-injection surface.
@@ -61,8 +61,8 @@ switch (command) {
   case "check":
   case "list":
   case "urls":
-    // rad-compile dispatches on its own first argument, so pass the command.
-    run("rad-compile.js", [command, ...rest]);
+    // rastack-compile dispatches on its own first argument, so pass the command.
+    run("rastack-compile.js", [command, ...rest]);
     break;
   case "serve":
     runRust("serve");
@@ -72,7 +72,7 @@ switch (command) {
     break;
   case "wasm":
     // Compile the API to WebAssembly for in-browser local dev.
-    run("rad-wasm-build.js", rest);
+    run("rastack-wasm-build.js", rest);
     break;
   case "scan":
     run("scan.js");
@@ -89,13 +89,13 @@ switch (command) {
     console.error(
       `Unknown command: "${command}"\n\n` +
         `Usage:\n` +
-        `  rad compile [resourcesDir] [outDir]\n` +
-        `  rad check | list | urls [resourcesDir]\n` +
-        `  rad generate [--schema-only]\n` +
-        `  rad serve | admin [--warehouse dir]\n` +
-        `  rad wasm                                Compile the API to WebAssembly (browser local dev)\n` +
-        `  rad scan   [files...] [--fail-on-pii]\n` +
-        `  rad seed   [--env dev|staging] [--source gs://bucket/ | ./myapp-dev/]\n`,
+        `  rastack compile [resourcesDir] [outDir]\n` +
+        `  rastack check | list | urls [resourcesDir]\n` +
+        `  rastack generate [--schema-only]\n` +
+        `  rastack serve | admin [--warehouse dir]\n` +
+        `  rastack wasm                                Compile the API to WebAssembly (browser local dev)\n` +
+        `  rastack scan   [files...] [--fail-on-pii]\n` +
+        `  rastack seed   [--env dev|staging] [--source gs://bucket/ | ./myapp-dev/]\n`,
     );
     process.exit(1);
 }

package/src/scan.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 /**
- * rad scan
+ * rastack scan
  *
  * Scans CSV files in myapp-dev/ for PII column patterns and schema issues.
  * Exits non-zero if violations are found and --fail-on-pii is passed.
  *
  * Usage:
- *   rad scan [files...] [--fail-on-pii]
- *   rad scan myapp-dev/passengers.csv myapp-dev/flights.csv --fail-on-pii
+ *   rastack scan [files...] [--fail-on-pii]
+ *   rastack scan myapp-dev/passengers.csv myapp-dev/flights.csv --fail-on-pii
  */
 
 import path from "path";
@@ -80,7 +80,7 @@ if (totalViolations > 0) {
   );
   if (failOnPii) {
     console.error(
-      "Failing because --fail-on-pii is set. Remove PII data or add access policies in .rad/policies/.",
+      "Failing because --fail-on-pii is set. Remove PII data or add access policies in .rastack/policies/.",
     );
     process.exit(1);
   }