@pixel-point/toolcraft 0.0.2

package/LICENSE.md

@@ -0,0 +1,98 @@
+# Toolcraft Designer License
+
+Copyright (c) 2026 Pixel Point
+
+This license governs Toolcraft, including the CLI, starter template, runtime,
+UI components, documentation, and any generated application code that includes
+Toolcraft source code.
+
+## 1. Permitted Designer Use
+
+You may use Toolcraft for personal, educational, internal evaluation, and
+designer client work.
+
+Designer client work means using Toolcraft as part of paid design, development,
+consulting, or creative services to create a custom application for a specific
+client.
+
+Designers, freelancers, agencies, and studios may deliver generated
+applications to their clients, and those clients may use the delivered
+application for their own business, website, marketing, internal workflows, or
+product presentation.
+
+## 2. Generated Applications
+
+A generated application may be modified, deployed, and used by the designer or
+the designer's client as a custom client deliverable.
+
+You may not sell, sublicense, redistribute, publish, or offer generated
+applications as standalone products, stock templates, starter kits, theme packs,
+marketplace items, or reusable application templates.
+
+## 3. AI-Assisted Development
+
+You may use AI coding assistants, AI agents, design assistants, large language
+models, editors, IDE assistants, and similar tools to create, inspect, modify,
+refactor, test, document, deploy, or maintain generated applications for any use
+permitted by this license.
+
+This includes tools such as Codex, Claude, ChatGPT, Cursor, and similar
+assistants. Using those tools to work on Toolcraft projects or generated
+applications does not, by itself, make your use a prohibited AI software, AI app
+builder, AI design tool, code generation platform, or competing generator tool.
+
+This section does not allow you to package, embed, host, or provide Toolcraft or
+generated applications as part of a paid AI software product, AI app builder, AI
+design tool, code generation platform, or competing generator service.
+
+## 4. Prohibited Uses
+
+You may not use Toolcraft, generated applications, or any Toolcraft runtime,
+starter, UI, or template code as part of:
+
+- paid AI software;
+- AI app builders;
+- AI design tools;
+- website builders;
+- app builders;
+- design-to-code SaaS products;
+- code generation platforms;
+- template marketplaces;
+- competing generator tools;
+- any product or service whose primary purpose is to let third parties generate,
+  resell, or reuse applications based on Toolcraft.
+
+These uses require a separate commercial license from Pixel Point.
+
+## 5. No Hosted Generator or Resale Rights
+
+You may not provide Toolcraft or substantially similar functionality to third
+parties as a hosted service, API, plugin, marketplace product, or downloadable
+generator without a separate commercial license.
+
+## 6. No Trademark Rights
+
+This license does not grant rights to use the Pixel Point or Toolcraft names,
+logos, branding, or trademarks except to identify Toolcraft as the tool used to
+create a project.
+
+## 7. Ownership
+
+You own the original design, content, configuration, and product-specific code
+that you create.
+
+Pixel Point retains ownership of Toolcraft, including the CLI, starter template,
+runtime, UI components, documentation, and copied Toolcraft source code included
+in generated applications.
+
+## 8. Commercial Licensing
+
+If your intended use is not allowed by this license, you must obtain a separate
+commercial license before using Toolcraft for that purpose.
+
+Contact: licensing@pixel-point.com
+
+## 9. No Warranty
+
+Toolcraft is provided "as is", without warranty of any kind. Pixel Point is not
+liable for damages arising from use of Toolcraft or generated applications.

package/README.md

@@ -0,0 +1,41 @@
+# Toolcraft CLI
+
+Package entrypoint for creating standalone Toolcraft apps.
+
+```bash
+npx @pixel-point/toolcraft create
+```
+
+The create command uses the current directory when no target directory is passed, prompts for missing project values in an interactive terminal, generates the app, runs `pnpm install`, then prints the command to start the dev server.
+
+## License
+
+Toolcraft is distributed under the Toolcraft Designer License in `LICENSE.md`.
+Designer client work is permitted under that license. Using AI coding assistants
+or agents such as Codex, Claude, ChatGPT, Cursor, or similar tools to work on
+generated apps is permitted. Platform, generator, AI software product,
+app-builder, website-builder, template-marketplace, and resale uses require a
+separate commercial license from Pixel Point.
+
+Scripted usage:
+
+```bash
+npx @pixel-point/toolcraft create my-toolcraft-app --name my-toolcraft-app --yes --force
+```
+
+Local source test without publishing:
+
+```bash
+mkdir -p /tmp/toolcraft-local-cli-test
+cd /tmp/toolcraft-local-cli-test
+node /Users/alex/Projects/primeui-v2/cli/bin/toolcraft.mjs --name local-cli-test --yes --force --no-install
+```
+
+Local tarball test, matching the published package layout:
+
+```bash
+cd cli
+npm pack --pack-destination /tmp
+cd ..
+TOOLCRAFT_SKIP_INSTALL=1 npm exec --package /tmp/pixel-point-toolcraft-0.0.0.tgz -- toolcraft create /tmp/toolcraft-pack-exec-test --name pack-exec-test --yes --force
+```

package/bin/create-toolcraft-app.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { runToolcraftCli } from "../src/cli.mjs";
+
+await runToolcraftCli(["create", ...process.argv.slice(2)], {
+  cwd: process.cwd(),
+  env: process.env,
+});

package/bin/toolcraft.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { runToolcraftCli } from "../src/cli.mjs";
+
+await runToolcraftCli(process.argv.slice(2), {
+  cwd: process.cwd(),
+  env: process.env,
+});

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@pixel-point/toolcraft",
+  "version": "0.0.2",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "module",
+  "bin": {
+    "toolcraft": "./bin/toolcraft.mjs",
+    "create-toolcraft-app": "./bin/create-toolcraft-app.mjs"
+  },
+  "files": [
+    "LICENSE.md",
+    "README.md",
+    "bin",
+    "scripts",
+    "src",
+    "templates",
+    "package.json"
+  ],
+  "scripts": {
+    "prepack": "node scripts/prepare-pack.mjs",
+    "test": "node --test src/*.test.mjs",
+    "typecheck": "node --check bin/toolcraft.mjs && node --check bin/create-toolcraft-app.mjs && node --check scripts/*.mjs && node --check src/*.mjs"
+  }
+}

package/scripts/prepare-pack.mjs

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { copyDirectory, removeDirectory } from "../src/copy-recursive.mjs";
+
+const packageRoot = path.resolve(fileURLToPath(new URL("..", import.meta.url)));
+const repoRoot = path.resolve(packageRoot, "..");
+const templatesRoot = path.join(packageRoot, "templates");
+
+const sources = [
+  {
+    from: path.join(repoRoot, "starter"),
+    to: path.join(templatesRoot, "starter"),
+  },
+  {
+    from: path.join(repoRoot, "packages/ui/src"),
+    to: path.join(templatesRoot, "ui"),
+  },
+  {
+    from: path.join(repoRoot, "packages/toolcraft-runtime/src"),
+    to: path.join(templatesRoot, "runtime"),
+  },
+];
+
+await removeDirectory(templatesRoot);
+
+for (const source of sources) {
+  await copyDirectory(source.from, source.to);
+}

package/src/cli.mjs

@@ -0,0 +1,392 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline/promises";
+
+import { pathExists } from "./copy-recursive.mjs";
+import { generateToolcraft } from "./generate.mjs";
+import { sanitizePackageName } from "./package-json.mjs";
+
+const DEFAULT_PROJECT_NAME = "my-toolcraft-app";
+
+function writeLine(stream, message = "") {
+  stream.write(`${message}\n`);
+}
+
+function writeBlock(stream, message) {
+  stream.write(message.endsWith("\n") ? message : `${message}\n`);
+}
+
+function getStdout(context) {
+  return context.stdout ?? process.stdout;
+}
+
+function getStderr(context) {
+  return context.stderr ?? process.stderr;
+}
+
+function getStdin(context) {
+  return context.stdin ?? process.stdin;
+}
+
+function setExitCode(context, exitCode) {
+  if (typeof context.setExitCode === "function") {
+    context.setExitCode(exitCode);
+    return;
+  }
+
+  process.exitCode = exitCode;
+}
+
+function canPrompt(context) {
+  const stdin = getStdin(context);
+  const stdout = getStdout(context);
+  return Boolean(context.forcePrompts || (stdin.isTTY && stdout.isTTY));
+}
+
+function createMissingValueError(valueName) {
+  return new Error(`${valueName} is required. Pass it with a flag, or run in an interactive terminal.`);
+}
+
+function defaultNameForTarget(cwd, targetDir) {
+  if (!targetDir) {
+    return sanitizePackageName(path.basename(cwd)) || DEFAULT_PROJECT_NAME;
+  }
+
+  const basename = path.basename(path.resolve(cwd, targetDir));
+  return sanitizePackageName(basename === "." ? path.basename(cwd) : basename) || DEFAULT_PROJECT_NAME;
+}
+
+async function promptText(context, label, defaultValue) {
+  if (context.prompts?.text) {
+    return context.prompts.text({ label, defaultValue });
+  }
+
+  if (!canPrompt(context)) {
+    throw createMissingValueError(label);
+  }
+
+  const rl = readline.createInterface({
+    input: getStdin(context),
+    output: getStdout(context),
+  });
+
+  try {
+    const answer = await rl.question(`? ${label} (${defaultValue}): `);
+    return answer.trim() || defaultValue;
+  } finally {
+    rl.close();
+  }
+}
+
+async function promptConfirm(context, label, defaultValue = false) {
+  if (context.prompts?.confirm) {
+    return context.prompts.confirm({ label, defaultValue });
+  }
+
+  if (!canPrompt(context)) {
+    return defaultValue;
+  }
+
+  const suffix = defaultValue ? "Y/n" : "y/N";
+  const rl = readline.createInterface({
+    input: getStdin(context),
+    output: getStdout(context),
+  });
+
+  try {
+    const answer = (await rl.question(`? ${label} (${suffix}): `)).trim().toLowerCase();
+    if (!answer) {
+      return defaultValue;
+    }
+
+    return ["y", "yes"].includes(answer);
+  } finally {
+    rl.close();
+  }
+}
+
+async function directoryHasMeaningfulEntries(directoryPath) {
+  if (!(await pathExists(directoryPath))) {
+    return false;
+  }
+
+  const stats = await fs.stat(directoryPath);
+  if (!stats.isDirectory()) {
+    return true;
+  }
+
+  const entries = await fs.readdir(directoryPath);
+  return entries.some((entry) => entry !== ".DS_Store");
+}
+
+function readOptionValue(argv, index, optionName) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`${optionName} requires a value.`);
+  }
+
+  return value;
+}
+
+export function parseCreateArgs(argv) {
+  const options = {
+    force: false,
+    help: false,
+    install: true,
+    name: undefined,
+    targetDir: undefined,
+    yes: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === "--force" || arg === "-f") {
+      options.force = true;
+      continue;
+    }
+
+    if (arg === "--yes" || arg === "-y") {
+      options.yes = true;
+      continue;
+    }
+
+    if (arg === "--no-install") {
+      options.install = false;
+      continue;
+    }
+
+    if (arg === "--name") {
+      options.name = readOptionValue(argv, index, "--name");
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--dir") {
+      if (options.targetDir) {
+        throw new Error("Pass either a positional target directory or --dir, not both.");
+      }
+
+      options.targetDir = readOptionValue(argv, index, "--dir");
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+
+    if (options.targetDir) {
+      throw new Error(`Unexpected extra argument: ${arg}`);
+    }
+
+    options.targetDir = arg;
+  }
+
+  return options;
+}
+
+export async function resolveCreateOptions(parsedOptions, context = {}) {
+  const cwd = path.resolve(context.cwd ?? process.cwd());
+  let name = parsedOptions.name?.trim();
+  let targetDir = parsedOptions.targetDir?.trim();
+  let promptedForName = false;
+
+  if (!name) {
+    const defaultName = defaultNameForTarget(cwd, targetDir);
+    const shouldPrompt = !parsedOptions.yes && (context.prompts?.text || canPrompt(context));
+    if (shouldPrompt) {
+      name = await promptText(context, "Project name", defaultName);
+      promptedForName = true;
+    } else {
+      name = defaultName;
+    }
+  }
+
+  name = sanitizePackageName(name);
+
+  if (!targetDir) {
+    const shouldCreateNamedFolder =
+      promptedForName && (await directoryHasMeaningfulEntries(cwd));
+    targetDir = shouldCreateNamedFolder ? `./${name}` : ".";
+  }
+
+  targetDir = targetDir || ".";
+  const resolvedTargetDir = path.resolve(cwd, targetDir);
+  let force = parsedOptions.force;
+
+  if (!force && (await directoryHasMeaningfulEntries(resolvedTargetDir))) {
+    const shouldContinue =
+      !parsedOptions.yes &&
+      (await promptConfirm(context, "Directory is not empty. Continue?", false));
+
+    if (!shouldContinue) {
+      throw new Error(
+        `Target directory is not empty: ${resolvedTargetDir}. Use --force to write into it.`,
+      );
+    }
+
+    force = true;
+  }
+
+  return {
+    force,
+    install: parsedOptions.install && context.env?.TOOLCRAFT_SKIP_INSTALL !== "1",
+    name,
+    targetDir,
+  };
+}
+
+function runCommand(command, args, options = {}, context = {}) {
+  if (context.runCommand) {
+    return context.runCommand(command, args, options);
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      shell: process.platform === "win32",
+      stdio: options.stdio ?? "inherit",
+    });
+
+    child.on("error", reject);
+    child.on("exit", (exitCode) => {
+      if (exitCode === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error(`${command} ${args.join(" ")} failed with exit code ${exitCode}.`));
+    });
+  });
+}
+
+export async function runCreateCommand(parsedOptions, context = {}) {
+  const cwd = path.resolve(context.cwd ?? process.cwd());
+  const stdout = getStdout(context);
+  const createOptions = await resolveCreateOptions(parsedOptions, context);
+
+  const result = await generateToolcraft({
+    cwd,
+    force: createOptions.force,
+    name: createOptions.name,
+    targetDir: createOptions.targetDir,
+  });
+
+  if (createOptions.install) {
+    writeLine(stdout, "");
+    writeLine(stdout, "Installing dependencies with pnpm...");
+    await runCommand(
+      "pnpm",
+      ["install"],
+      {
+        cwd: result.targetDir,
+        env: {
+          ...process.env,
+          ...(context.env ?? {}),
+        },
+        stdio: "inherit",
+      },
+      context,
+    );
+  }
+
+  const sameDirectory = result.targetDir === cwd;
+
+  writeLine(stdout, "");
+  writeLine(stdout, `Created ${result.packageName} at ${result.targetDir}`);
+  writeLine(stdout, "");
+  writeLine(stdout, "Next steps:");
+  if (!sameDirectory) {
+    const displayTargetDir = path.isAbsolute(createOptions.targetDir)
+      ? result.targetDir
+      : result.relativeTargetDir;
+    writeLine(stdout, `  cd ${displayTargetDir}`);
+  }
+  writeLine(stdout, "  pnpm dev");
+
+  return result;
+}
+
+export function getMainHelp() {
+  return `Usage:
+  npx @pixel-point/toolcraft [create] [target-dir] [options]
+  toolcraft [create] [target-dir] [options]
+
+Commands:
+  create    Create a standalone Toolcraft template app. This is the default command.
+
+Options:
+  --help, -h    Show this help message.`;
+}
+
+export function getCreateHelp() {
+  return `Usage:
+  npx @pixel-point/toolcraft create [target-dir] [options]
+
+Creates a standalone Toolcraft template app. When target-dir is omitted, the current directory is used.
+Missing project values are prompted in an interactive terminal.
+
+Options:
+  --name <name>    Package name for the generated app.
+  --dir <dir>      Target directory for the generated app.
+  --force, -f      Allow writing into a non-empty target folder.
+  --yes, -y        Use defaults for missing values and skip prompts.
+  --no-install     Skip automatic pnpm install. Intended for local CLI tests and automation.
+  --help, -h       Show this help message.`;
+}
+
+export async function runToolcraftCli(argv, context = {}) {
+  const stdout = getStdout(context);
+  const stderr = getStderr(context);
+
+  try {
+    const [command, ...rest] = argv;
+
+    if (command === "--help" || command === "-h") {
+      writeBlock(stdout, getMainHelp());
+      return { ok: true };
+    }
+
+    if (!command || command.startsWith("-")) {
+      const createOptions = parseCreateArgs(argv);
+      if (createOptions.help) {
+        writeBlock(stdout, getMainHelp());
+        return { ok: true };
+      }
+
+      const result = await runCreateCommand(createOptions, context);
+      return { ok: true, result };
+    }
+
+    if (command !== "create") {
+      throw new Error(`Unknown command: ${command}`);
+    }
+
+    const createOptions = parseCreateArgs(rest);
+    if (createOptions.help) {
+      writeBlock(stdout, getCreateHelp());
+      return { ok: true };
+    }
+
+    const result = await runCreateCommand(createOptions, context);
+    return { ok: true, result };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    writeLine(stderr, message);
+
+    if (context.throwOnError) {
+      throw error;
+    }
+
+    setExitCode(context, 1);
+    return { ok: false, error };
+  }
+}