@jskit-ai/create-app 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/create-app",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Scaffold minimal JSKIT app shells.",
   "type": "module",
   "files": [
@@ -10,30 +10,33 @@
     "README.md"
   ],
   "scripts": {
-    "test": "node --test"
+    "test": "node --test test/*.test.js"
   },
   "bin": {
     "jskit-create-app": "bin/jskit-create-app.js"
   },
   "exports": {
-    ".": "./src/shared/index.js"
+    ".": "./src/index.js",
+    "./server": "./src/server/index.js",
+    "./client": "./src/client/index.js"
   },
   "dependencies": {},
   "engines": {
     "node": "20.x"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mobily-enterprises/jskit-ai.git",
-    "directory": "packages/tooling/create-app"
+    "directory": "tooling/create-app"
   },
   "bugs": {
     "url": "https://github.com/mobily-enterprises/jskit-ai/issues"
   },
-  "homepage": "https://github.com/mobily-enterprises/jskit-ai/tree/main/packages/tooling/create-app#readme",
+  "homepage": "https://github.com/mobily-enterprises/jskit-ai/tree/main/tooling/create-app#readme",
   "keywords": [
     "jskit",
     "scaffold",

package/README.md

@@ -1,24 +0,0 @@
-# @jskit-ai/create-app
-
-Scaffold a minimal JSKIT app shell from in-repo templates.
-
-## Usage
-
-```bash
-jskit-create-app my-app
-```
-
-```bash
-jskit-create-app --interactive
-```
-
-## Options
-
-- `--template <name>` template name under `templates/` (default `base-shell`)
-- `--title <text>` override the generated app title placeholder
-- `--target <path>` output directory (default `./<app-name>`)
-- `--initial-bundles <preset>` optional framework preset: `none`, `db`, or `db-auth`
-- `--db-provider <provider>` provider for `db` presets: `mysql` or `postgres`
-- `--force` allow writes into non-empty target directories
-- `--dry-run` preview writes only
-- `--interactive` prompt for app values

package/bin/jskit-create-app.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-import { runCliEntrypoint } from "../src/shared/cliEntrypoint.js";
-import { runCli } from "../src/shared/index.js";
-
-await runCliEntrypoint(runCli);

package/src/shared/cliEntrypoint.js

@@ -1,25 +0,0 @@
-import process from "node:process";
-
-function shellQuote(value) {
-  const raw = String(value ?? "");
-  if (!raw) {
-    return "''";
-  }
-  if (/^[A-Za-z0-9_./:=+,-]+$/.test(raw)) {
-    return raw;
-  }
-  return `'${raw.replace(/'/g, "'\\''")}'`;
-}
-
-async function runCliEntrypoint(runCli, argv = process.argv.slice(2)) {
-  if (typeof runCli !== "function") {
-    throw new TypeError("runCliEntrypoint requires a runCli function");
-  }
-
-  const exitCode = await runCli(argv);
-  if (exitCode !== 0) {
-    process.exit(exitCode);
-  }
-}
-
-export { shellQuote, runCliEntrypoint };

package/src/shared/index.js

@@ -1,637 +0,0 @@
-import { chmod, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-import process from "node:process";
-import { createInterface } from "node:readline/promises";
-import { fileURLToPath } from "node:url";
-import { shellQuote } from "./cliEntrypoint.js";
-
-const DEFAULT_TEMPLATE = "base-shell";
-const DEFAULT_INITIAL_BUNDLES = "none";
-const DEFAULT_DB_PROVIDER = "mysql";
-const INITIAL_BUNDLE_PRESETS = new Set(["none", "db", "db-auth"]);
-const DB_PROVIDERS = new Set(["mysql", "postgres"]);
-const ALLOWED_EXISTING_TARGET_ENTRIES = new Set([".git"]);
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
-const TEMPLATES_ROOT = path.join(PACKAGE_ROOT, "templates");
-
-function createCliError(message, { showUsage = false, exitCode = 1 } = {}) {
-  const error = new Error(String(message || "Command failed."));
-  error.showUsage = Boolean(showUsage);
-  error.exitCode = Number.isInteger(exitCode) ? exitCode : 1;
-  return error;
-}
-
-function toAppTitle(appName) {
-  const words = String(appName)
-    .trim()
-    .split(/[-_]+/)
-    .filter(Boolean)
-    .map((word) => `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`);
-
-  return words.length > 0 ? words.join(" ") : "App";
-}
-
-function normalizeInitialBundlesPreset(value, { showUsage = true } = {}) {
-  const normalized = String(value || DEFAULT_INITIAL_BUNDLES).trim().toLowerCase();
-  if (INITIAL_BUNDLE_PRESETS.has(normalized)) {
-    return normalized;
-  }
-
-  throw createCliError(
-    `Invalid --initial-bundles value "${value}". Expected one of: none, db, db-auth.`,
-    { showUsage }
-  );
-}
-
-function normalizeDbProvider(value, { showUsage = true } = {}) {
-  const normalized = String(value || DEFAULT_DB_PROVIDER).trim().toLowerCase();
-  if (DB_PROVIDERS.has(normalized)) {
-    return normalized;
-  }
-
-  throw createCliError(
-    `Invalid --db-provider value "${value}". Expected one of: mysql, postgres.`,
-    { showUsage }
-  );
-}
-
-function buildInitialBundleCommands(initialBundles, dbProvider) {
-  const normalizedPreset = normalizeInitialBundlesPreset(initialBundles, { showUsage: false });
-  const normalizedProvider = normalizeDbProvider(dbProvider, { showUsage: false });
-
-  const commands = [];
-  if (normalizedPreset === "db" || normalizedPreset === "db-auth") {
-    commands.push(`npx jskit add db --provider ${normalizedProvider} --no-install`);
-  }
-  if (normalizedPreset === "db-auth") {
-    commands.push("npx jskit add auth-base --no-install");
-  }
-
-  return commands;
-}
-
-function buildProgressiveBundleCommands(dbProvider) {
-  const normalizedProvider = normalizeDbProvider(dbProvider, { showUsage: false });
-  return [
-    `npx jskit add db --provider ${normalizedProvider} --no-install`,
-    "npx jskit add auth-base --no-install"
-  ];
-}
-
-function validateAppName(appName, { showUsage = true } = {}) {
-  if (!appName || typeof appName !== "string") {
-    throw createCliError("Missing app name.", { showUsage });
-  }
-
-  if (!/^[a-z0-9][a-z0-9-]*$/.test(appName)) {
-    throw createCliError(
-      `Invalid app name "${appName}". Use lowercase letters, numbers, and dashes only.`,
-      { showUsage }
-    );
-  }
-}
-
-function parseOptionWithValue(argv, index, optionName) {
-  const nextValue = argv[index + 1];
-  if (!nextValue || nextValue.startsWith("-")) {
-    throw createCliError(`Option ${optionName} requires a value.`, {
-      showUsage: true
-    });
-  }
-  return {
-    value: nextValue,
-    nextIndex: index + 1
-  };
-}
-
-function parseCliArgs(argv) {
-  const args = Array.isArray(argv) ? argv : [];
-  const options = {
-    appName: null,
-    appTitle: null,
-    template: DEFAULT_TEMPLATE,
-    target: null,
-    initialBundles: DEFAULT_INITIAL_BUNDLES,
-    dbProvider: DEFAULT_DB_PROVIDER,
-    force: false,
-    dryRun: false,
-    help: false,
-    interactive: false
-  };
-
-  const positionalArgs = [];
-
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = String(args[index] || "");
-
-    if (arg === "--help" || arg === "-h") {
-      options.help = true;
-      continue;
-    }
-
-    if (arg === "--force") {
-      options.force = true;
-      continue;
-    }
-
-    if (arg === "--dry-run") {
-      options.dryRun = true;
-      continue;
-    }
-
-    if (arg === "--interactive") {
-      options.interactive = true;
-      continue;
-    }
-
-    if (arg === "--template") {
-      const { value, nextIndex } = parseOptionWithValue(args, index, "--template");
-      options.template = value;
-      index = nextIndex;
-      continue;
-    }
-
-    if (arg.startsWith("--template=")) {
-      options.template = arg.slice("--template=".length);
-      continue;
-    }
-
-    if (arg === "--target") {
-      const { value, nextIndex } = parseOptionWithValue(args, index, "--target");
-      options.target = value;
-      index = nextIndex;
-      continue;
-    }
-
-    if (arg.startsWith("--target=")) {
-      options.target = arg.slice("--target=".length);
-      continue;
-    }
-
-    if (arg === "--title") {
-      const { value, nextIndex } = parseOptionWithValue(args, index, "--title");
-      options.appTitle = value;
-      index = nextIndex;
-      continue;
-    }
-
-    if (arg.startsWith("--title=")) {
-      options.appTitle = arg.slice("--title=".length);
-      continue;
-    }
-
-    if (arg === "--initial-bundles") {
-      const { value, nextIndex } = parseOptionWithValue(args, index, "--initial-bundles");
-      options.initialBundles = value;
-      index = nextIndex;
-      continue;
-    }
-
-    if (arg.startsWith("--initial-bundles=")) {
-      options.initialBundles = arg.slice("--initial-bundles=".length);
-      continue;
-    }
-
-    if (arg === "--db-provider") {
-      const { value, nextIndex } = parseOptionWithValue(args, index, "--db-provider");
-      options.dbProvider = value;
-      index = nextIndex;
-      continue;
-    }
-
-    if (arg.startsWith("--db-provider=")) {
-      options.dbProvider = arg.slice("--db-provider=".length);
-      continue;
-    }
-
-    if (arg.startsWith("-")) {
-      throw createCliError(`Unknown option: ${arg}`, {
-        showUsage: true
-      });
-    }
-
-    positionalArgs.push(arg);
-  }
-
-  if (positionalArgs.length > 1) {
-    throw createCliError("Only one <app-name> argument is allowed.", {
-      showUsage: true
-    });
-  }
-
-  if (positionalArgs.length === 1) {
-    options.appName = positionalArgs[0];
-  }
-
-  if (!options.help && !options.interactive && positionalArgs.length !== 1) {
-    throw createCliError("Expected exactly one <app-name> argument.", {
-      showUsage: true
-    });
-  }
-
-  return options;
-}
-
-function printUsage(stream = process.stderr) {
-  stream.write("Usage: jskit-create-app [app-name] [options]\n");
-  stream.write("\n");
-  stream.write("Options:\n");
-  stream.write(`  --template <name>  Template folder under templates/ (default: ${DEFAULT_TEMPLATE})\n`);
-  stream.write("  --title <text>     App title used for template replacements\n");
-  stream.write("  --target <path>    Target directory (default: ./<app-name>)\n");
-  stream.write("  --initial-bundles <preset>  Optional bundle preset: none | db | db-auth (default: none)\n");
-  stream.write("  --db-provider <provider>    Database provider for db presets: mysql | postgres (default: mysql)\n");
-  stream.write("  --force            Allow writing into a non-empty target directory\n");
-  stream.write("  --dry-run          Print planned writes without changing the filesystem\n");
-  stream.write("  --interactive      Prompt for app values instead of passing all flags\n");
-  stream.write("  -h, --help         Show this help\n");
-}
-
-function applyPlaceholders(source, replacements) {
-  let output = String(source || "");
-  for (const [placeholder, value] of Object.entries(replacements)) {
-    output = output.split(placeholder).join(String(value));
-  }
-  return output;
-}
-
-async function resolveTemplateDirectory(templateName) {
-  const cleanTemplate = String(templateName || "").trim();
-  if (!cleanTemplate) {
-    throw createCliError("Template name cannot be empty.", {
-      showUsage: true
-    });
-  }
-
-  const templateDir = path.join(TEMPLATES_ROOT, cleanTemplate);
-
-  try {
-    const templateStats = await stat(templateDir);
-    if (!templateStats.isDirectory()) {
-      throw createCliError(`Template "${cleanTemplate}" is not a directory.`);
-    }
-  } catch (error) {
-    if (error?.code === "ENOENT") {
-      throw createCliError(`Unknown template "${cleanTemplate}".`);
-    }
-    throw error;
-  }
-
-  return templateDir;
-}
-
-async function ensureTargetDirectoryState(targetDirectory, { force = false, dryRun = false } = {}) {
-  let targetExists = false;
-
-  try {
-    const targetStats = await stat(targetDirectory);
-    targetExists = true;
-    if (!targetStats.isDirectory()) {
-      throw createCliError(`Target path exists and is not a directory: ${targetDirectory}`);
-    }
-  } catch (error) {
-    if (error?.code !== "ENOENT") {
-      throw error;
-    }
-  }
-
-  if (!targetExists) {
-    if (!dryRun) {
-      await mkdir(targetDirectory, { recursive: true });
-    }
-    return;
-  }
-
-  const entries = await readdir(targetDirectory);
-  const blockingEntries = entries.filter((entry) => !ALLOWED_EXISTING_TARGET_ENTRIES.has(entry));
-  if (blockingEntries.length > 0 && !force) {
-    throw createCliError(
-      `Target directory is not empty: ${targetDirectory}. Use --force to allow writing into it.`
-    );
-  }
-}
-
-function sortEntriesByName(entries) {
-  return [...entries].sort((left, right) => left.name.localeCompare(right.name));
-}
-
-function mapTemplatePathToTargetPath(relativePath) {
-  const pathSegments = String(relativePath || "")
-    .split(path.sep)
-    .map((segment) => (segment === "gitignore" ? ".gitignore" : segment));
-  return pathSegments.join(path.sep);
-}
-
-async function writeTemplateFile(sourcePath, targetPath, replacements) {
-  const sourceBody = await readFile(sourcePath, "utf8");
-  const targetBody = applyPlaceholders(sourceBody, replacements);
-
-  await mkdir(path.dirname(targetPath), { recursive: true });
-  await writeFile(targetPath, targetBody, "utf8");
-
-  const sourceStats = await stat(sourcePath);
-  await chmod(targetPath, sourceStats.mode & 0o777);
-}
-
-async function copyTemplateDirectory({ templateDirectory, targetDirectory, replacements, dryRun }) {
-  const touchedFiles = [];
-
-  async function traverse(relativePath = "") {
-    const sourceDirectory = path.join(templateDirectory, relativePath);
-    const sourceEntries = sortEntriesByName(await readdir(sourceDirectory, { withFileTypes: true }));
-
-    for (const entry of sourceEntries) {
-      const entryRelativePath = relativePath ? path.join(relativePath, entry.name) : entry.name;
-      const targetRelativePath = mapTemplatePathToTargetPath(entryRelativePath);
-      const sourcePath = path.join(templateDirectory, entryRelativePath);
-      const targetPath = path.join(targetDirectory, targetRelativePath);
-
-      if (entry.isDirectory()) {
-        if (!dryRun) {
-          await mkdir(targetPath, { recursive: true });
-        }
-        await traverse(entryRelativePath);
-        continue;
-      }
-
-      if (entry.isFile()) {
-        touchedFiles.push(targetRelativePath);
-        if (!dryRun) {
-          await writeTemplateFile(sourcePath, targetPath, replacements);
-        }
-        continue;
-      }
-
-      throw createCliError(`Unsupported template entry type at ${entryRelativePath}.`);
-    }
-  }
-
-  await traverse();
-  return touchedFiles;
-}
-
-function toRelativeTargetLabel(cwd, targetDirectory) {
-  const relativePath = path.relative(cwd, targetDirectory);
-  if (!relativePath || relativePath === ".") {
-    return ".";
-  }
-  if (relativePath.startsWith("..")) {
-    return targetDirectory;
-  }
-  return `./${relativePath}`;
-}
-
-async function askQuestion(readline, label, defaultValue) {
-  const suffix = defaultValue ? ` (${defaultValue})` : "";
-  const response = await readline.question(`${label}${suffix}: `);
-  const trimmed = response.trim();
-  return trimmed || defaultValue;
-}
-
-async function askYesNoQuestion(readline, label, defaultValue) {
-  const prompt = defaultValue ? "Y/n" : "y/N";
-
-  while (true) {
-    const response = await readline.question(`${label} [${prompt}]: `);
-    const normalized = response.trim().toLowerCase();
-    if (!normalized) {
-      return defaultValue;
-    }
-    if (normalized === "y" || normalized === "yes") {
-      return true;
-    }
-    if (normalized === "n" || normalized === "no") {
-      return false;
-    }
-  }
-}
-
-function createReadlineInterface({ stdin = process.stdin, stdout = process.stdout } = {}) {
-  return createInterface({
-    input: stdin,
-    output: stdout
-  });
-}
-
-async function collectInteractiveOptions({
-  parsed,
-  stdout = process.stdout,
-  stderr = process.stderr,
-  stdin = process.stdin,
-  readlineFactory = createReadlineInterface
-}) {
-  const readline = readlineFactory({
-    stdin,
-    stdout
-  });
-
-  try {
-    let appName = String(parsed.appName || "").trim();
-    while (true) {
-      appName = await askQuestion(readline, "App name", appName);
-      try {
-        validateAppName(appName, { showUsage: false });
-        break;
-      } catch (error) {
-        stderr.write(`Error: ${error?.message || String(error)}\n`);
-      }
-    }
-
-    const defaultTitle = String(parsed.appTitle || "").trim() || toAppTitle(appName);
-    const appTitle = await askQuestion(readline, "App title", defaultTitle);
-
-    const defaultTarget = String(parsed.target || "").trim() || appName;
-    const target = await askQuestion(readline, "Target directory", defaultTarget);
-
-    const defaultTemplate = String(parsed.template || "").trim() || DEFAULT_TEMPLATE;
-    const template = await askQuestion(readline, "Template", defaultTemplate);
-
-    const force = await askYesNoQuestion(
-      readline,
-      "Allow writing into non-empty target directories",
-      Boolean(parsed.force)
-    );
-
-    let initialBundles = normalizeInitialBundlesPreset(parsed.initialBundles, { showUsage: false });
-    while (true) {
-      const candidate = await askQuestion(
-        readline,
-        "Initial bundle preset (none|db|db-auth)",
-        initialBundles
-      );
-      try {
-        initialBundles = normalizeInitialBundlesPreset(candidate, { showUsage: false });
-        break;
-      } catch (error) {
-        stderr.write(`Error: ${error?.message || String(error)}\n`);
-      }
-    }
-
-    let dbProvider = normalizeDbProvider(parsed.dbProvider, { showUsage: false });
-    if (initialBundles === "db" || initialBundles === "db-auth") {
-      while (true) {
-        const candidate = await askQuestion(readline, "DB provider (mysql|postgres)", dbProvider);
-        try {
-          dbProvider = normalizeDbProvider(candidate, { showUsage: false });
-          break;
-        } catch (error) {
-          stderr.write(`Error: ${error?.message || String(error)}\n`);
-        }
-      }
-    }
-
-    return {
-      appName,
-      appTitle,
-      target,
-      template,
-      force,
-      initialBundles,
-      dbProvider
-    };
-  } finally {
-    readline.close();
-  }
-}
-
-export async function createApp({
-  appName,
-  appTitle = null,
-  template = DEFAULT_TEMPLATE,
-  target = null,
-  initialBundles = DEFAULT_INITIAL_BUNDLES,
-  dbProvider = DEFAULT_DB_PROVIDER,
-  force = false,
-  dryRun = false,
-  cwd = process.cwd()
-}) {
-  const resolvedAppName = String(appName || "").trim();
-  validateAppName(resolvedAppName);
-
-  const resolvedAppTitle = String(appTitle || "").trim() || toAppTitle(resolvedAppName);
-  const resolvedInitialBundles = normalizeInitialBundlesPreset(initialBundles);
-  const resolvedDbProvider = normalizeDbProvider(dbProvider);
-
-  const resolvedCwd = path.resolve(cwd);
-  const targetDirectory = path.resolve(resolvedCwd, target ? String(target) : resolvedAppName);
-  const templateDirectory = await resolveTemplateDirectory(template);
-
-  await ensureTargetDirectoryState(targetDirectory, {
-    force,
-    dryRun
-  });
-
-  const replacements = {
-    __APP_NAME__: resolvedAppName,
-    __APP_TITLE__: resolvedAppTitle
-  };
-
-  const touchedFiles = await copyTemplateDirectory({
-    templateDirectory,
-    targetDirectory,
-    replacements,
-    dryRun
-  });
-
-  return {
-    appName: resolvedAppName,
-    appTitle: resolvedAppTitle,
-    template: String(template),
-    initialBundles: resolvedInitialBundles,
-    dbProvider: resolvedDbProvider,
-    selectedBundleCommands: buildInitialBundleCommands(resolvedInitialBundles, resolvedDbProvider),
-    progressiveBundleCommands: buildProgressiveBundleCommands(resolvedDbProvider),
-    targetDirectory,
-    dryRun,
-    touchedFiles
-  };
-}
-
-export async function runCli(
-  argv,
-  {
-    stdout = process.stdout,
-    stderr = process.stderr,
-    stdin = process.stdin,
-    cwd = process.cwd(),
-    readlineFactory = createReadlineInterface
-  } = {}
-) {
-  try {
-    const parsed = parseCliArgs(argv);
-
-    if (parsed.help) {
-      printUsage(stdout);
-      return 0;
-    }
-
-    const resolvedOptions = parsed.interactive
-      ? {
-          ...parsed,
-          ...(await collectInteractiveOptions({
-            parsed,
-            stdout,
-            stderr,
-            stdin,
-            readlineFactory
-          }))
-        }
-      : parsed;
-
-    const result = await createApp({
-      appName: resolvedOptions.appName,
-      appTitle: resolvedOptions.appTitle,
-      template: resolvedOptions.template,
-      target: resolvedOptions.target,
-      initialBundles: resolvedOptions.initialBundles,
-      dbProvider: resolvedOptions.dbProvider,
-      force: resolvedOptions.force,
-      dryRun: resolvedOptions.dryRun,
-      cwd
-    });
-
-    const targetLabel = toRelativeTargetLabel(path.resolve(cwd), result.targetDirectory);
-    if (result.dryRun) {
-      stdout.write(
-        `[dry-run] Would create app "${result.appName}" from template "${result.template}" at ${targetLabel}.\n`
-      );
-    } else {
-      stdout.write(`Created app "${result.appName}" from template "${result.template}" at ${targetLabel}.\n`);
-    }
-
-    stdout.write(`${result.dryRun ? "Planned" : "Written"} files (${result.touchedFiles.length}):\n`);
-    for (const filePath of result.touchedFiles) {
-      stdout.write(`- ${filePath}\n`);
-    }
-
-    if (!result.dryRun) {
-      stdout.write("\n");
-      stdout.write("Next steps:\n");
-      stdout.write(`- cd ${shellQuote(targetLabel)}\n`);
-      stdout.write("- npm install\n");
-      stdout.write("- npm run dev\n");
-
-      stdout.write("\n");
-      if (result.selectedBundleCommands.length > 0) {
-        stdout.write(`Initial framework bundle commands (${result.initialBundles}):\n`);
-        for (const command of result.selectedBundleCommands) {
-          stdout.write(`- ${command}\n`);
-        }
-      } else {
-        stdout.write("Add framework capabilities when ready:\n");
-        for (const command of result.progressiveBundleCommands) {
-          stdout.write(`- ${command}\n`);
-        }
-      }
-    }
-
-    return 0;
-  } catch (error) {
-    stderr.write(`Error: ${error?.message || String(error)}\n`);
-    if (error?.showUsage) {
-      stderr.write("\n");
-      printUsage(stderr);
-    }
-    return Number.isInteger(error?.exitCode) ? error.exitCode : 1;
-  }
-}

package/templates/base-shell/Procfile

@@ -1 +0,0 @@
-web: npm run start

package/templates/base-shell/README.md

@@ -1,39 +0,0 @@
-# __APP_TITLE__
-
-Minimal JSKIT starter shell.
-
-## What This Is
-
-This is the smallest practical JSKIT app host:
-
-- tiny Fastify server (`/api/v1/health`)
-- tiny Vue client shell
-- standardized scripts via `@jskit-ai/app-scripts`
-
-## What This Is Not
-
-This app intentionally does not include:
-
-- db wiring
-- auth/workspace modules
-- billing/chat/social/ai modules
-- app-local framework composition engines
-
-Those are layered in later as framework packs/modules.
-
-## Run
-
-```bash
-npm install
-npm run dev
-npm run server
-npm run test
-npm run test:client
-```
-
-## Progressive Bundles
-
-```bash
-npx jskit add db --provider mysql --no-install
-npx jskit add auth-base --no-install
-```

package/templates/base-shell/app.scripts.config.mjs

@@ -1,3 +0,0 @@
-import { createNodeVueFastifyScriptsConfig } from "@jskit-ai/app-scripts";
-
-export default createNodeVueFastifyScriptsConfig();

package/templates/base-shell/bin/server.js

@@ -1,8 +0,0 @@
-import { startServer } from "../server.js";
-
-try {
-  await startServer();
-} catch (error) {
-  console.error("Failed to start __APP_NAME__ server:", error);
-  process.exitCode = 1;
-}

package/templates/base-shell/eslint.config.mjs

@@ -1,10 +0,0 @@
-import { baseConfig, nodeConfig, webConfig } from "@jskit-ai/config-eslint";
-
-export default [
-  {
-    ignores: ["dist/**", "node_modules/**", "coverage/**"]
-  },
-  ...baseConfig,
-  ...webConfig,
-  ...nodeConfig
-];

package/templates/base-shell/favicon.svg

@@ -1,7 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
-  <rect width="64" height="64" rx="12" fill="#111827" />
-  <path
-    d="M20 16h24v8H28v20c0 6-4 10-10 10h-2v-8h2c2 0 2-1 2-3V16z"
-    fill="#22d3ee"
-  />
-</svg>

package/templates/base-shell/gitignore

@@ -1,7 +0,0 @@
-node_modules/
-dist/
-coverage/
-test-results/
-.env
-.env.*
-!.env.example

package/templates/base-shell/index.html

@@ -1,13 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <title>__APP_TITLE__</title>
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="/src/%VITE_CLIENT_ENTRY%"></script>
-  </body>
-</html>

package/templates/base-shell/package.json

@@ -1,39 +0,0 @@
-{
-  "name": "__APP_NAME__",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "description": "Minimal JSKIT base app (Fastify + Vue)",
-  "engines": {
-    "node": "20.x"
-  },
-  "bin": {
-    "jskit": "node_modules/@jskit-ai/jskit/packages/tooling/jskit/bin/jskit.js"
-  },
-  "scripts": {
-    "server": "jskit-app-scripts server",
-    "start": "jskit-app-scripts start",
-    "dev": "jskit-app-scripts dev",
-    "build": "jskit-app-scripts build",
-    "preview": "jskit-app-scripts preview",
-    "lint": "jskit-app-scripts lint",
-    "lint:process-env": "jskit-app-scripts lint:process-env",
-    "test": "jskit-app-scripts test",
-    "test:client": "jskit-app-scripts test:client"
-  },
-  "dependencies": {
-    "@jskit-ai/app-scripts": "0.1.0",
-    "@jskit-ai/server-runtime-core": "file:node_modules/@jskit-ai/jskit/packages/runtime/server-runtime-core",
-    "@jskit-ai/surface-routing": "file:node_modules/@jskit-ai/jskit/packages/surface-routing",  
-    "fastify": "^5.7.4",
-    "vue": "^3.5.13"
-  },
-  "devDependencies": {
-    "@jskit-ai/config-eslint": "0.1.0",
-    "@jskit-ai/jskit": "github:mobily-enterprises/jskit-ai",
-    "@vitejs/plugin-vue": "^5.2.1",
-    "eslint": "^9.39.1",
-    "vite": "^6.1.0",
-    "vitest": "^4.0.18"
-  }
-}

package/templates/base-shell/package.json.ACTUAL_CORRECT

@@ -1,38 +0,0 @@
-{
-  "name": "__APP_NAME__",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "description": "Minimal JSKIT base app (Fastify + Vue)",
-  "engines": {
-    "node": "20.x"
-  },
-  "bin": {
-    "jskit": "node_modules/@jskit-ai/jskit/packages/tooling/jskit/bin/jskit.js"
-  },
-  "scripts": {
-    "server": "jskit-app-scripts server",
-    "start": "jskit-app-scripts start",
-    "dev": "jskit-app-scripts dev",
-    "build": "jskit-app-scripts build",
-    "preview": "jskit-app-scripts preview",
-    "lint": "jskit-app-scripts lint",
-    "lint:process-env": "jskit-app-scripts lint:process-env",
-    "test": "jskit-app-scripts test",
-    "test:client": "jskit-app-scripts test:client"
-  },
-  "dependencies": {
-    "@jskit-ai/app-scripts": "0.1.0",
-    "@jskit-ai/server-runtime-core": "file:node_modules/@jskit-ai/jskit/packages/runtime/server-runtime-core",
-    "fastify": "^5.7.4",
-    "vue": "^3.5.13"
-  },
-  "devDependencies": {
-    "@jskit-ai/config-eslint": "0.1.0",
-    "@jskit-ai/jskit": "github:mobily-enterprises/jskit-ai",
-    "@vitejs/plugin-vue": "^5.2.1",
-    "eslint": "^9.39.1",
-    "vite": "^6.1.0",
-    "vitest": "^4.0.18"
-  }
-}

package/templates/base-shell/server/lib/runtimeEnv.js

@@ -1,16 +0,0 @@
-function toPort(value, fallback = 3000) {
-  const parsed = Number.parseInt(String(value || "").trim(), 10);
-  if (Number.isInteger(parsed) && parsed > 0) {
-    return parsed;
-  }
-  return fallback;
-}
-
-function resolveRuntimeEnv() {
-  return {
-    PORT: toPort(process.env.PORT, 3000),
-    HOST: String(process.env.HOST || "").trim() || "0.0.0.0"
-  };
-}
-
-export { resolveRuntimeEnv };

package/templates/base-shell/server.js

@@ -1,98 +0,0 @@
-import Fastify from "fastify";
-import { resolveRuntimeEnv } from "./server/lib/runtimeEnv.js";
-import { registerApiRouteDefinitions } from "@jskit-ai/server-runtime-core/apiRouteRegistration";
-import { createServerRuntimeFromApp, applyContributedRuntimeLifecycle } from "@jskit-ai/server-runtime-core/serverContributions";
-import path from "node:path";
-
-function registerFallbackHealthRoute(app) {
-  app.get("/api/v1/health", async () => {
-    return {
-      ok: true,
-      app: "__APP_NAME__"
-    };
-  });
-}
-
-async function registerContributedRuntime(app, { appRoot, runtimeEnv }) {
-  try {
-    const composed = await createServerRuntimeFromApp({
-      appRoot,
-      strict: false,
-      dependencies: {
-        env: runtimeEnv,
-        logger: app.log
-      },
-      routeConfig: {}
-    });
-
-    const routeCount = Array.isArray(composed.routes) ? composed.routes.length : 0;
-    if (routeCount > 0) {
-      registerApiRouteDefinitions(app, {
-        routes: composed.routes
-      });
-    }
-
-    const lifecycleResult = await applyContributedRuntimeLifecycle({
-      app,
-      runtimeResult: composed,
-      dependencies: {
-        env: runtimeEnv,
-        logger: app.log
-      }
-    });
-
-    app.log.info(
-      {
-        routeCount,
-        pluginCount: lifecycleResult.pluginCount,
-        workerCount: lifecycleResult.workerCount,
-        onBootCount: lifecycleResult.onBootCount,
-        packageOrder: composed.packageOrder
-      },
-      "Registered JSKIT contributed server runtime."
-    );
-
-    return {
-      enabled: true,
-      routeCount,
-      pluginCount: lifecycleResult.pluginCount,
-      workerCount: lifecycleResult.workerCount,
-      onBootCount: lifecycleResult.onBootCount
-    };
-  } catch (error) {
-    const message = String(error?.message || "");
-    if (message.includes("Lock file not found:")) {
-      return {
-        enabled: false,
-        routeCount: 0
-      };
-    }
-    throw error;
-  }
-}
-
-async function createServer() {
-  const app = Fastify({ logger: true });
-  const runtimeEnv = resolveRuntimeEnv();
-  const appRoot = path.resolve(process.cwd());
-  const contributed = await registerContributedRuntime(app, {
-    appRoot,
-    runtimeEnv
-  });
-  if (!contributed.enabled || contributed.routeCount < 1) {
-    registerFallbackHealthRoute(app);
-  }
-
-  return app;
-}
-
-async function startServer(options = {}) {
-  const runtimeEnv = resolveRuntimeEnv();
-  const port = Number(options?.port) || runtimeEnv.PORT;
-  const host = String(options?.host || "").trim() || runtimeEnv.HOST;
-  const app = await createServer();
-  await app.listen({ port, host });
-  return app;
-}
-
-export { createServer, startServer };

package/templates/base-shell/src/App.vue

@@ -1,24 +0,0 @@
-<script setup>
-import { onMounted, ref } from "vue";
-
-const appTitle = "__APP_TITLE__";
-const health = ref("loading...");
-
-onMounted(async () => {
-  try {
-    const response = await fetch("/api/v1/health");
-    const payload = await response.json();
-    health.value = payload?.ok ? "ok" : "unhealthy";
-  } catch {
-    health.value = "unreachable";
-  }
-});
-</script>
-
-<template>
-  <main style="font-family: sans-serif; max-width: 48rem; margin: 3rem auto; padding: 0 1rem;">
-    <h1>{{ appTitle }}</h1>
-    <p>Minimal starter shell is running.</p>
-    <p><strong>Health:</strong> {{ health }}</p>
-  </main>
-</template>

package/templates/base-shell/src/main.js

@@ -1,4 +0,0 @@
-import { createApp } from "vue";
-import App from "./App.vue";
-
-createApp(App).mount("#app");

package/templates/base-shell/tests/client/smoke.vitest.js

@@ -1,7 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-describe("__APP_NAME__ client smoke", () => {
-  it("runs vitest in __APP_NAME__", () => {
-    expect(true).toBe(true);
-  });
-});

package/templates/base-shell/tests/server/minimalShell.contract.test.js

@@ -1,96 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { access, readdir, readFile } from "node:fs/promises";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const APP_ROOT = path.resolve(__dirname, "../..");
-
-const EXPECTED_RUNTIME_DEPENDENCIES = Object.freeze([
-  "@jskit-ai/app-scripts",
-  "@jskit-ai/server-runtime-core",
-  "fastify",
-  "vue"
-]);
-
-const EXPECTED_DEV_DEPENDENCIES = Object.freeze([
-  "@jskit-ai/config-eslint",
-  "@jskit-ai/jskit",
-  "@vitejs/plugin-vue",
-  "eslint",
-  "vite",
-  "vitest"
-]);
-
-const EXPECTED_TOP_LEVEL_ENTRIES = Object.freeze([
-  "Procfile",
-  "README.md",
-  "app.scripts.config.mjs",
-  "bin",
-  "eslint.config.mjs",
-  "favicon.svg",
-  "gitignore",
-  "index.html",
-  "package.json",
-  "package.json.ACTUAL_CORRECT",
-  "server.js",
-  "server",
-  "src",
-  "tests",
-  "vite.config.mjs",
-  "vite.shared.mjs"
-]);
-
-async function readPackageJson() {
-  const packageJsonPath = path.join(APP_ROOT, "package.json");
-  const raw = await readFile(packageJsonPath, "utf8");
-  return JSON.parse(raw);
-}
-
-function sortStrings(values) {
-  return [...values].sort((left, right) => left.localeCompare(right));
-}
-
-function sortedKeys(record) {
-  return sortStrings(Object.keys(record || {}));
-}
-
-async function readTopLevelEntries() {
-  const entries = await readdir(APP_ROOT, { withFileTypes: true });
-  const ignored = new Set([
-    "node_modules",
-    "dist",
-    "coverage",
-    "test-results",
-    "package-lock.json",
-    "pnpm-lock.yaml",
-    "yarn.lock"
-  ]);
-  return entries
-    .map((entry) => entry.name)
-    .filter((name) => !name.startsWith("."))
-    .filter((name) => !ignored.has(name));
-}
-
-test("minimal shell keeps strict dependency allowlist", async () => {
-  const packageJson = await readPackageJson();
-  assert.deepEqual(
-    sortedKeys(packageJson.dependencies),
-    [...EXPECTED_RUNTIME_DEPENDENCIES].sort((left, right) => left.localeCompare(right))
-  );
-  assert.deepEqual(
-    sortedKeys(packageJson.devDependencies),
-    [...EXPECTED_DEV_DEPENDENCIES].sort((left, right) => left.localeCompare(right))
-  );
-});
-
-test("starter shell keeps a strict top-level footprint", async () => {
-  const entries = await readTopLevelEntries();
-  assert.deepEqual(sortStrings(entries), sortStrings(EXPECTED_TOP_LEVEL_ENTRIES));
-});
-
-test("legacy app.manifest scaffold is removed from starter shell", async () => {
-  await assert.rejects(access(path.join(APP_ROOT, "framework/app.manifest.mjs")), /ENOENT/);
-});

package/templates/base-shell/tests/server/smoke.test.js

@@ -1,19 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createServer } from "../../server.js";
-
-test("GET /api/v1/health returns ok payload", async () => {
-  const app = await createServer();
-  const response = await app.inject({
-    method: "GET",
-    url: "/api/v1/health"
-  });
-
-  assert.equal(response.statusCode, 200);
-  assert.deepEqual(response.json(), {
-    ok: true,
-    app: "__APP_NAME__"
-  });
-
-  await app.close();
-});

package/templates/base-shell/vite.config.mjs

@@ -1,43 +0,0 @@
-import { defineConfig } from "vite";
-import vue from "@vitejs/plugin-vue";
-import { toPositiveInt } from "./vite.shared.mjs";
-
-const devPort = toPositiveInt(process.env.VITE_DEV_PORT, 5173);
-const apiProxyTarget = String(process.env.VITE_API_PROXY_TARGET || "").trim() || "http://localhost:3000";
-const clientEntry = (() => {
-  const normalized = String(process.env.VITE_CLIENT_ENTRY || "").trim();
-  if (!normalized) {
-    return "/src/main.js";
-  }
-  if (normalized.startsWith("/")) {
-    return normalized;
-  }
-  if (normalized.startsWith("src/")) {
-    return `/${normalized}`;
-  }
-  return `/src/${normalized}`;
-})();
-
-export default defineConfig({
-  plugins: [
-    vue(),
-    {
-      name: "jskit-client-entry",
-      transformIndexHtml(source) {
-        return String(source || "").replace(/\/src\/main\.js/g, clientEntry);
-      }
-    }
-  ],
-  test: {
-    include: ["tests/client/**/*.vitest.js"]
-  },
-  server: {
-    port: devPort,
-    proxy: {
-      "/api": {
-        target: apiProxyTarget,
-        changeOrigin: true
-      }
-    }
-  }
-});

package/templates/base-shell/vite.shared.mjs

@@ -1,9 +0,0 @@
-function toPositiveInt(value, fallback) {
-  const parsed = Number.parseInt(String(value || "").trim(), 10);
-  if (Number.isInteger(parsed) && parsed > 0) {
-    return parsed;
-  }
-  return fallback;
-}
-
-export { toPositiveInt };