create-keeno 0.0.0-stage → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iliesw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# create-keeno
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Scaffolds a new [Keeno](https://github.com/iliesw/Keeno) project.
+
+```bash
+bun create keeno my-app
+npm create keeno@latest my-app
+pnpm create keeno my-app
+yarn create keeno my-app
+```
+
+It asks for anything not given on the command line:
+
+| Option | |
+|---|---|
+| `[dir]` | Where to create the project. Its name becomes the package name. |
+| `-t, --template` | `router`: pages in `src/pages` with file-based routing, a layout and a 404 page (default). `minimal`: a single `App.kn`. |
+| `--tailwind`, `--no-tailwind` | Add Tailwind CSS (default: no). |
+| `--install`, `--no-install` | Install dependencies with the package manager that ran the command. |
+| `-f, --force` | Write into a non-empty directory. |
+| `-y, --yes` | Use the defaults for everything not given, without asking. |
+
+The project uses Vite, TypeScript and `keeno-check`, with `dev`, `build`, `preview` and `check` scripts.
+
+The Keeno package versions it writes are the ones released with this version of create-keeno.

package/dist/chunks/scaffold-wbdjagd0.js

@@ -0,0 +1,326 @@
+// ../../../../../../../tmp/keeno-build/create-keeno/src/scaffold.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var TEMPLATES = {
+  router: "Pages in src/pages with file-based routing, a layout and a 404 page",
+  minimal: "A single App.kn component"
+};
+var KEENO_PACKAGES = ["@inflector/keeno", "@inflector/keeno-router", "@inflector/vite-plugin-keeno", "@inflector/keeno-check"];
+var VERSIONS = {
+  vite: "^7.0.0",
+  typescript: "^5.6.3",
+  tailwindcss: "^4.1.0",
+  "@tailwindcss/vite": "^4.1.0"
+};
+function keenoVersions() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  let pkg;
+  for (;; ) {
+    const file = path.join(dir, "package.json");
+    if (existsSync(file)) {
+      pkg = JSON.parse(readFileSync(file, "utf8"));
+      if (pkg.name === "create-keeno")
+        break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      throw new Error("create-keeno: cannot find its own package.json");
+    dir = parent;
+  }
+  const out = {};
+  for (const name of KEENO_PACKAGES) {
+    const range = pkg.devDependencies?.[name];
+    if (!range)
+      throw new Error(`create-keeno: no version for ${name}`);
+    out[name] = range.startsWith("workspace:") ? `^${workspaceVersion(path.dirname(dir), name)}` : range;
+  }
+  return out;
+}
+function workspaceVersion(packagesDir, name) {
+  for (const entry of readdirSync(packagesDir)) {
+    const file = path.join(packagesDir, entry, "package.json");
+    if (!existsSync(file))
+      continue;
+    const pkg = JSON.parse(readFileSync(file, "utf8"));
+    if (pkg.name === name)
+      return pkg.version;
+  }
+  throw new Error(`create-keeno: workspace package ${name} not found in ${packagesDir}`);
+}
+function toPackageName(dir) {
+  const name = path.basename(path.resolve(dir)).trim().toLowerCase().replace(/[^a-z0-9._~-]+/g, "-").replace(/^[._-]+|-+$/g, "");
+  return name || "keeno-app";
+}
+var sortKeys = (o) => Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b)));
+function projectFiles(options) {
+  const { name, template, tailwind } = options;
+  const v = options.versions ?? keenoVersions();
+  const router = template === "router";
+  const dependencies = { "@inflector/keeno": v["@inflector/keeno"] };
+  if (router)
+    dependencies["@inflector/keeno-router"] = v["@inflector/keeno-router"];
+  const devDependencies = {
+    "@inflector/keeno-check": v["@inflector/keeno-check"],
+    "@inflector/vite-plugin-keeno": v["@inflector/vite-plugin-keeno"],
+    typescript: VERSIONS.typescript,
+    vite: VERSIONS.vite
+  };
+  if (tailwind) {
+    devDependencies.tailwindcss = VERSIONS.tailwindcss;
+    devDependencies["@tailwindcss/vite"] = VERSIONS["@tailwindcss/vite"];
+  }
+  const pkg = {
+    name,
+    private: true,
+    version: "0.0.0",
+    type: "module",
+    scripts: { dev: "vite", build: "vite build", preview: "vite preview", check: "keeno-check" },
+    dependencies: sortKeys(dependencies),
+    devDependencies: sortKeys(devDependencies)
+  };
+  const files = {
+    "package.json": JSON.stringify(pkg, null, 2) + `
+`,
+    ".gitignore": `node_modules
+dist
+*.local
+.DS_Store
+`,
+    "README.md": readme(name, router),
+    "index.html": `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${escapeHtml(name)}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`,
+    "tsconfig.json": `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["src", "vite.config.ts"]
+}
+`,
+    "vite.config.ts": viteConfig(router, tailwind),
+    "src/env.d.ts": `/// <reference types="vite/client" />
+${router ? `/// <reference types="@inflector/vite-plugin-keeno/client" />
+` : ""}
+declare module '*.kn' {
+  const Component: import('@inflector/keeno').Component
+  export default Component
+}
+`,
+    "src/main.ts": router ? `import { mount } from '@inflector/keeno'
+import Pages from 'virtual:keeno-pages'
+import './app.css'
+
+// Routes come from the files in src/pages.
+mount(Pages, document.getElementById('app')!)
+` : `import { mount } from '@inflector/keeno'
+import App from './App.kn'
+import './app.css'
+
+mount(App, document.getElementById('app')!)
+`,
+    "src/app.css": (tailwind ? `@import 'tailwindcss';
+
+` : "") + GLOBAL_CSS
+  };
+  if (router) {
+    files["src/pages/_layout.kn"] = LAYOUT;
+    files["src/pages/index.kn"] = counterPage("Home");
+    files["src/pages/about.kn"] = ABOUT;
+    files["src/pages/_404.kn"] = NOT_FOUND;
+  } else {
+    files["src/App.kn"] = counterPage(name);
+  }
+  return files;
+}
+function scaffold(dir, options) {
+  const root = path.resolve(dir);
+  const files = projectFiles(options);
+  for (const [file, contents] of Object.entries(files)) {
+    const dest = path.join(root, file);
+    mkdirSync(path.dirname(dest), { recursive: true });
+    writeFileSync(dest, contents);
+  }
+  return { dir: root, files: Object.keys(files) };
+}
+function isEmptyDir(dir) {
+  if (!existsSync(dir))
+    return true;
+  return readdirSync(dir).every((f) => f === ".git");
+}
+var escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function viteConfig(router, tailwind) {
+  const imports = [`import { defineConfig } from 'vite'`, `import keeno from '@inflector/vite-plugin-keeno'`];
+  if (tailwind)
+    imports.push(`import tailwindcss from '@tailwindcss/vite'`);
+  const plugins = [router ? `keeno({ useFileRouter: true, pages: './src/pages' })` : "keeno()"];
+  if (tailwind)
+    plugins.push("tailwindcss()");
+  return `${imports.join(`
+`)}
+
+export default defineConfig({
+${router ? `  // File-based routing: each .kn file in src/pages is a route.
+` : ""}  plugins: [${plugins.join(", ")}],
+})
+`;
+}
+function readme(name, router) {
+  return `# ${name}
+
+A [Keeno](https://github.com/iliesw/Keeno) app.
+
+| Command | |
+|---|---|
+| \`dev\` | Start the dev server |
+| \`build\` | Build for production into \`dist/\` |
+| \`preview\` | Serve the production build |
+| \`check\` | Type-check every \`.kn\` and \`.ts\` file |
+
+${router ? "Pages live in `src/pages`: `index.kn` is `/`, `about.kn` is `/about`, `_layout.kn` wraps every page and `_404.kn` renders unknown URLs." : "Start editing `src/App.kn`."}
+`;
+}
+var GLOBAL_CSS = `:root {
+  font-family: system-ui, sans-serif;
+  color: #1f2937;
+  background: #f5f5f4;
+}
+
+body {
+  margin: 0;
+}
+`;
+var counterPage = (title) => `<script lang="ts">
+  const count = state(0)
+  const doubled = derived(() => count * 2)
+</script>
+
+<main>
+  <h1>${escapeHtml(title)}</h1>
+  <p>Clicked {count} times ({doubled} doubled)</p>
+  <button type="button" onClick={() => count.set(count + 1)}>+1</button>
+</main>
+
+<style>
+  main {
+    max-width: 32rem;
+    margin: 2rem auto;
+    padding: 1.5rem;
+    background: white;
+    border-radius: 12px;
+    box-shadow: 0 1px 4px rgb(0 0 0 / 0.1);
+  }
+  h1 {
+    margin-top: 0;
+    color: teal;
+  }
+  button {
+    background: teal;
+    color: white;
+    border: 0;
+    border-radius: 6px;
+    padding: 0.4rem 0.8rem;
+    cursor: pointer;
+  }
+</style>
+`;
+var LAYOUT = `<script lang="ts">
+  import type { Children } from '@inflector/keeno'
+  import { Link } from '@inflector/keeno-router'
+  // Wraps every page and stays mounted while you navigate between them.
+  const { children } = props<{ children: Children }>()
+</script>
+
+<nav>
+  <Link href="/" exact>Home</Link>
+  <Link href="/about">About</Link>
+</nav>
+{children}
+
+<style>
+  nav {
+    display: flex;
+    justify-content: center;
+    gap: 0.5rem;
+    padding: 1rem;
+  }
+  a {
+    color: teal;
+    text-decoration: none;
+    padding: 0.3rem 0.8rem;
+    border-radius: 6px;
+  }
+  .active {
+    background: rgb(0 128 128 / 0.12);
+  }
+</style>
+`;
+var ABOUT = `<script lang="ts">
+  import { Link } from '@inflector/keeno-router'
+</script>
+
+<main>
+  <h1>About</h1>
+  <p>
+    This page is <code>src/pages/about.kn</code>. Add a file to <code>src/pages</code> to add a route.
+  </p>
+  <p><Link href="/">Back home</Link></p>
+</main>
+
+<style>
+  main {
+    max-width: 32rem;
+    margin: 2rem auto;
+    padding: 1.5rem;
+    background: white;
+    border-radius: 12px;
+  }
+  h1 {
+    margin-top: 0;
+  }
+  a {
+    color: teal;
+  }
+</style>
+`;
+var NOT_FOUND = `<script lang="ts">
+  import { Link, useRoute } from '@inflector/keeno-router'
+  const route = useRoute()
+</script>
+
+<main>
+  <h1>Not found</h1>
+  <p>There is no page at <code>{route.path}</code>. <Link href="/">Go home</Link></p>
+</main>
+
+<style>
+  main {
+    max-width: 32rem;
+    margin: 2rem auto;
+    padding: 1.5rem;
+    background: white;
+    border-radius: 12px;
+  }
+  a {
+    color: teal;
+  }
+</style>
+`;
+
+export { TEMPLATES, keenoVersions, toPackageName, projectFiles, scaffold, isEmptyDir };

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import {
+  TEMPLATES,
+  isEmptyDir,
+  scaffold,
+  toPackageName
+} from "./chunks/scaffold-wbdjagd0.js";
+
+// ../../../../../../../tmp/keeno-build/create-keeno/src/cli.ts
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+var HELP = `Usage: create-keeno [dir] [options]
+
+  dir                 where to create the project (default: asked, or keeno-app)
+  -t, --template      ${Object.entries(TEMPLATES).map(([k, d]) => `${k}: ${d}`).join(`
+                      `)}
+  --tailwind          add Tailwind CSS (--no-tailwind to skip)
+  --install           install dependencies after scaffolding
+  -f, --force         write into a non-empty directory
+  -y, --yes           use the defaults for everything not given
+`;
+var color = process.stdout.isTTY && !process.env.NO_COLOR;
+var paint = (code) => (s) => color ? `\x1B[${code}m${s}\x1B[0m` : s;
+var bold = paint(1);
+var dim = paint(2);
+var cyan = paint(36);
+var red = paint(31);
+function fail(message, code = 1) {
+  process.stderr.write(`${red("create-keeno:")} ${message}
+`);
+  process.exit(code);
+}
+var args = process.argv.slice(2);
+if (args.includes("-h") || args.includes("--help")) {
+  process.stdout.write(HELP);
+  process.exit(0);
+}
+var dirArg;
+var template;
+var tailwind;
+var install;
+var force = false;
+var yes = false;
+for (let i = 0;i < args.length; i++) {
+  const a = args[i];
+  if (a === "-t" || a === "--template" || a.startsWith("--template=")) {
+    const value = a.includes("=") ? a.slice(a.indexOf("=") + 1) : args[++i];
+    if (!value || !(value in TEMPLATES))
+      fail(`unknown template ${value ?? "(none)"}; use ${Object.keys(TEMPLATES).join(" or ")}`, 2);
+    template = value;
+  } else if (a === "--tailwind")
+    tailwind = true;
+  else if (a === "--no-tailwind")
+    tailwind = false;
+  else if (a === "--install")
+    install = true;
+  else if (a === "--no-install")
+    install = false;
+  else if (a === "-f" || a === "--force")
+    force = true;
+  else if (a === "-y" || a === "--yes")
+    yes = true;
+  else if (a.startsWith("-"))
+    fail(`unknown option ${a}
+
+${HELP}`, 2);
+  else if (dirArg === undefined)
+    dirArg = a;
+  else
+    fail(`unexpected argument ${a}`, 2);
+}
+var interactive = !yes && !!process.stdin.isTTY && !!process.stdout.isTTY;
+var rl = interactive ? createInterface({ input: process.stdin, output: process.stdout }) : undefined;
+rl?.on("SIGINT", () => {
+  process.stdout.write(`
+`);
+  process.exit(130);
+});
+async function text(question, fallback) {
+  if (!rl)
+    return fallback;
+  const answer = (await rl.question(`${cyan("?")} ${bold(question)} ${dim(`(${fallback})`)} `)).trim();
+  return answer || fallback;
+}
+async function confirm(question, fallback) {
+  if (!rl)
+    return fallback;
+  for (;; ) {
+    const answer = (await rl.question(`${cyan("?")} ${bold(question)} ${dim(fallback ? "(Y/n)" : "(y/N)")} `)).trim().toLowerCase();
+    if (!answer)
+      return fallback;
+    if (answer === "y" || answer === "yes")
+      return true;
+    if (answer === "n" || answer === "no")
+      return false;
+  }
+}
+async function select(question, choices) {
+  const keys = Object.keys(choices);
+  if (!rl)
+    return keys[0];
+  process.stdout.write(`${cyan("?")} ${bold(question)}
+`);
+  keys.forEach((k, i) => process.stdout.write(`  ${cyan(String(i + 1))}. ${k} ${dim(`- ${choices[k]}`)}
+`));
+  for (;; ) {
+    const answer = (await rl.question(`  ${dim(`1-${keys.length}`)} ${dim("(1)")} `)).trim();
+    if (!answer)
+      return keys[0];
+    const picked = keys[Number(answer) - 1] ?? keys.find((k) => k === answer);
+    if (picked)
+      return picked;
+  }
+}
+function packageManager() {
+  const agent = process.env.npm_config_user_agent ?? "";
+  for (const pm of ["pnpm", "yarn", "bun"])
+    if (agent.startsWith(pm))
+      return pm;
+  return "npm";
+}
+process.stdout.write(`
+${bold(cyan("Keeno"))} ${dim("- create a new project")}
+
+`);
+var dir = dirArg ?? await text("Project directory", "keeno-app");
+var target = path.resolve(dir);
+if (!force && !isEmptyDir(target)) {
+  const proceed = await confirm(`${dir} is not empty. Write into it anyway?`, false);
+  if (!proceed)
+    fail(`${dir} is not empty (use --force to write into it)`);
+}
+template ??= yes ? "router" : await select("Template", TEMPLATES);
+tailwind ??= await confirm("Add Tailwind CSS?", false);
+var pm = packageManager();
+install ??= await confirm(`Install dependencies with ${pm}?`, interactive);
+rl?.close();
+var { files } = scaffold(target, { name: toPackageName(target), template, tailwind });
+process.stdout.write(`
+${dim(`Created ${files.length} files in`)} ${target}
+`);
+if (install) {
+  process.stdout.write(`
+${dim(`$ ${pm} install`)}
+`);
+  const r = spawnSync(pm, ["install"], { cwd: target, stdio: "inherit", shell: process.platform === "win32" });
+  if (r.status !== 0)
+    fail(`${pm} install failed; run it yourself in ${dir}`);
+}
+var run = (script) => pm === "npm" || pm === "bun" ? `${pm} run ${script}` : `${pm} ${script}`;
+var rel = path.relative(process.cwd(), target);
+var steps = [rel && `cd ${/\s/.test(rel) ? JSON.stringify(rel) : rel}`, !install && `${pm} install`, run("dev")].filter(Boolean);
+process.stdout.write(`
+${bold("Next:")}
+${steps.map((s) => `  ${cyan(s)}`).join(`
+`)}
+
+`);

package/dist/scaffold.d.ts

@@ -0,0 +1,31 @@
+export declare const TEMPLATES: {
+    readonly router: "Pages in src/pages with file-based routing, a layout and a 404 page";
+    readonly minimal: "A single App.kn component";
+};
+export type Template = keyof typeof TEMPLATES;
+export interface Options {
+    /** package.json `name`. */
+    name: string;
+    template: Template;
+    tailwind: boolean;
+    /** Version ranges of the Keeno packages, by package name (default: `keenoVersions()`). */
+    versions?: Record<string, string>;
+}
+/**
+ * Ranges for the Keeno packages, from this package's devDependencies: a published create-keeno has the
+ * released versions there (`bun pm pack` rewrites `workspace:` ranges); in the monorepo they are read
+ * from the sibling packages.
+ */
+export declare function keenoVersions(): Record<string, string>;
+/** A valid npm package name from a directory name. */
+export declare function toPackageName(dir: string): string;
+/** Every file of the new project, by path relative to its root. */
+export declare function projectFiles(options: Options): Record<string, string>;
+export interface ScaffoldResult {
+    dir: string;
+    files: string[];
+}
+/** Write the project into `dir` (created when missing). */
+export declare function scaffold(dir: string, options: Options): ScaffoldResult;
+/** True when `dir` is missing or has nothing but a .git directory. */
+export declare function isEmptyDir(dir: string): boolean;

package/dist/scaffold.js

@@ -0,0 +1,16 @@
+import {
+  TEMPLATES,
+  isEmptyDir,
+  keenoVersions,
+  projectFiles,
+  scaffold,
+  toPackageName
+} from "./chunks/scaffold-wbdjagd0.js";
+export {
+  TEMPLATES,
+  isEmptyDir,
+  keenoVersions,
+  projectFiles,
+  scaffold,
+  toPackageName
+};

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "create-keeno",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "description": "Scaffold a new Keeno project: npm create keeno",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iliesw/Keeno.git",
+    "directory": "packages/create-keeno"
+  },
+  "homepage": "https://github.com/iliesw/Keeno/tree/main/packages/create-keeno#readme",
+  "bugs": {
+    "url": "https://github.com/iliesw/Keeno/issues"
+  },
+  "keywords": [
+    "keeno",
+    "create",
+    "scaffold",
+    "template",
+    "cli"
+  ],
+  "type": "module",
+  "bin": {
+    "create-keeno": "./dist/cli.js"
+  },
+  "main": "./dist/scaffold.js",
+  "types": "./dist/scaffold.d.ts",
+  "exports": {
+    ".": {
+      "keeno-source": "./src/scaffold.ts",
+      "types": "./dist/scaffold.d.ts",
+      "import": "./dist/scaffold.js",
+      "default": "./dist/scaffold.js"
+    },
+    "./cli": {
+      "keeno-source": "./src/cli.ts",
+      "types": "./dist/cli.d.ts",
+      "import": "./dist/cli.js",
+      "default": "./dist/cli.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun ../../scripts/build-package.ts --target=node",
+    "prepack": "bun run build"
+  },
+  "//": "Not installed with the CLI: the generated project depends on these. `bun pm pack` turns the workspace ranges into the released versions, which the CLI reads from this file.",
+  "devDependencies": {
+    "@inflector/keeno": "^0.4.0",
+    "@inflector/keeno-check": "^0.1.3",
+    "@inflector/keeno-router": "^0.2.0",
+    "@inflector/vite-plugin-keeno": "^0.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}