create-factory 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# mastra-factory
+
+## 0.0.1
+
+### Patch Changes
+
+- Initial public package name claim for `mastra-factory`. Scaffold a Mastra Software Factory project with `npx mastra-factory`.

package/bin/cli.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/index.js

@@ -0,0 +1,297 @@
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/analytics.ts
+import { randomUUID } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+import { PostHog } from "posthog-node";
+var ANALYTICS_CONFIG_PATH = path.join(os.homedir(), ".mastra", "analytics.json");
+var POSTHOG_API_KEY = "phc_SBLpZVAB6jmHOct9CABq3PF0Yn5FU3G2FgT4xUr2XrT";
+var POSTHOG_HOST = "https://us.posthog.com";
+function isTelemetryEnabled() {
+  const value = process.env.MASTRA_TELEMETRY_DISABLED;
+  return !(value && value !== "0" && value.toLowerCase() !== "false");
+}
+function getOrCreateDistinctId() {
+  try {
+    if (existsSync(ANALYTICS_CONFIG_PATH)) {
+      const { distinctId: distinctId2 } = JSON.parse(readFileSync(ANALYTICS_CONFIG_PATH, "utf-8"));
+      if (distinctId2) return distinctId2;
+    }
+  } catch {
+  }
+  const distinctId = randomUUID();
+  try {
+    mkdirSync(path.dirname(ANALYTICS_CONFIG_PATH), { recursive: true });
+    writeFileSync(ANALYTICS_CONFIG_PATH, JSON.stringify({ distinctId, sessionId: randomUUID() }, null, 2));
+  } catch {
+  }
+  return distinctId;
+}
+var Analytics = class {
+  constructor(version) {
+    this.version = version;
+    if (!isTelemetryEnabled()) return;
+    try {
+      this.distinctId = getOrCreateDistinctId();
+      this.client = new PostHog(POSTHOG_API_KEY, { host: POSTHOG_HOST, flushAt: 1, flushInterval: 100 });
+    } catch {
+      this.client = void 0;
+    }
+  }
+  version;
+  client;
+  distinctId = "";
+  trackEvent(event, properties = {}) {
+    try {
+      this.client?.capture({
+        distinctId: this.distinctId,
+        event,
+        properties: { ...properties, cli: "mastra-factory", version: this.version }
+      });
+    } catch {
+    }
+  }
+  async shutdown(timeoutMs = 1e3) {
+    if (!this.client) return;
+    try {
+      await Promise.race([this.client.shutdown(), new Promise((resolve) => setTimeout(resolve, timeoutMs))]);
+    } catch {
+    }
+  }
+};
+
+// src/create.ts
+import fs2 from "fs";
+import path3 from "path";
+import * as p from "@clack/prompts";
+import color from "picocolors";
+
+// src/utils/clone.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/utils/exec.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function runInherit(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    let timeout;
+    let killTimer;
+    let timedOut = false;
+    if (options.timeoutMs) {
+      timeout = setTimeout(() => {
+        timedOut = true;
+        if (process.platform === "win32" && child.pid) {
+          const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+          killer.on("error", () => child.kill());
+          killer.on("exit", (code) => {
+            if (code !== 0) child.kill();
+          });
+        } else {
+          child.kill("SIGTERM");
+          killTimer = setTimeout(() => child.kill("SIGKILL"), 5e3);
+        }
+      }, options.timeoutMs);
+    }
+    const clearTimers = () => {
+      if (timeout) clearTimeout(timeout);
+      if (killTimer) clearTimeout(killTimer);
+    };
+    child.on("error", (err) => {
+      clearTimers();
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimers();
+      if (timedOut) reject(new Error(`${command} ${args.join(" ")} timed out after ${options.timeoutMs}ms`));
+      else if (code === 0) resolve();
+      else reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+
+// src/utils/clone.ts
+var DEFAULT_TEMPLATE_REPO = "https://github.com/mastra-ai/softwarefactory-template";
+async function cloneTemplate(options) {
+  const { repoUrl, projectPath, ref, localDir } = options;
+  if (fs.existsSync(projectPath)) {
+    throw new Error(`Directory ${path2.basename(projectPath)} already exists`);
+  }
+  if (localDir) {
+    fs.cpSync(localDir, projectPath, {
+      recursive: true,
+      filter: (src) => !src.split(path2.sep).includes("node_modules") && !src.split(path2.sep).includes(".git")
+    });
+    return;
+  }
+  const args = ["clone", "--depth", "1"];
+  if (ref) args.push("--branch", ref);
+  args.push(repoUrl, projectPath);
+  try {
+    await execFileAsync("git", args);
+  } catch (err) {
+    throw new Error(
+      `Failed to clone template from ${repoUrl}${ref ? `@${ref}` : ""}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  fs.rmSync(path2.join(projectPath, ".git"), { recursive: true, force: true });
+}
+function renameProject(projectPath, projectName) {
+  const pkgPath = path2.join(projectPath, "package.json");
+  const pkg2 = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  pkg2.name = toPackageName(projectName);
+  fs.writeFileSync(pkgPath, `${JSON.stringify(pkg2, null, 2)}
+`);
+}
+function toPackageName(name) {
+  const cleaned = name.toLowerCase().replace(/[^a-z0-9-_.~]+/g, "-").replace(/^[-_.]+|[-_.]+$/g, "");
+  return cleaned || "softwarefactory";
+}
+
+// src/utils/pm.ts
+function detectPackageManager() {
+  const agent = process.env.npm_config_user_agent ?? "";
+  if (agent.startsWith("pnpm")) return "pnpm";
+  if (agent.startsWith("yarn")) return "yarn";
+  if (agent.startsWith("bun")) return "bun";
+  return "npm";
+}
+
+// src/create.ts
+async function create(args) {
+  p.intro(color.inverse(" Mastra Software Factory "));
+  let projectName = args.projectName;
+  if (!projectName && args.useDefaults) {
+    projectName = "my-software-factory";
+  }
+  if (!projectName) {
+    const entered = await p.text({
+      message: "What is your project named?",
+      initialValue: "my-software-factory",
+      validate: (value) => {
+        if (!value?.trim()) return "Required";
+        if (fs2.existsSync(path3.resolve(value.trim()))) return `Directory ${value.trim()} already exists`;
+        return void 0;
+      }
+    });
+    if (p.isCancel(entered)) return cancel2();
+    projectName = entered.trim();
+  }
+  const projectPath = path3.resolve(projectName);
+  const packageManager = detectPackageManager();
+  args.analytics.trackEvent("sf_create_started", {
+    package_manager: packageManager,
+    non_interactive: Boolean(args.useDefaults)
+  });
+  const spinner2 = p.spinner();
+  spinner2.start("Downloading the Software Factory template...");
+  try {
+    await cloneTemplate({
+      repoUrl: DEFAULT_TEMPLATE_REPO,
+      projectPath,
+      ref: args.templateRef,
+      localDir: args.templateDir
+    });
+    renameProject(projectPath, projectName);
+    fs2.copyFileSync(path3.join(projectPath, ".env.example"), path3.join(projectPath, ".env"));
+    spinner2.stop("Template downloaded.");
+  } catch (err) {
+    spinner2.stop("Template download failed.");
+    throw err;
+  }
+  const installSpinner = p.spinner();
+  installSpinner.start(`Installing dependencies with ${packageManager} (this can take a few minutes)...`);
+  try {
+    await runInherit(packageManager, ["install"], {
+      cwd: projectPath,
+      timeoutMs: args.timeout
+    });
+    installSpinner.stop("Dependencies installed.");
+  } catch (err) {
+    installSpinner.stop("Dependency install failed.");
+    throw new Error(
+      `${err instanceof Error ? err.message : String(err)}
+You can retry manually: cd ${projectName} && ${packageManager} install`
+    );
+  }
+  let initGit = true;
+  if (!args.useDefaults) {
+    initGit = await p.confirm({ message: "Initialize a git repository?", initialValue: true });
+  }
+  if (!p.isCancel(initGit) && initGit) {
+    try {
+      await runInherit("git", ["init", "-q"], { cwd: projectPath });
+      await runInherit("git", ["add", "-A"], { cwd: projectPath });
+      await runInherit("git", ["commit", "-q", "-m", "Initial commit from mastra-factory"], {
+        cwd: projectPath
+      });
+    } catch {
+      p.log.warn("git init failed \u2014 you can initialize the repository yourself later.");
+    }
+  }
+  args.analytics.trackEvent("sf_create_completed", {
+    package_manager: packageManager,
+    non_interactive: Boolean(args.useDefaults)
+  });
+  const lines = [
+    color.green("Your Software Factory is ready!"),
+    "",
+    `${color.cyan("cd")} ${projectName}`,
+    color.cyan(`${packageManager} run dev`),
+    "",
+    `Factory UI     ${color.underline("http://localhost:5173")}`,
+    `Mastra Studio  ${color.underline("http://localhost:4111")}`,
+    "",
+    "Open the Factory UI to finish setup (models, integrations, database)."
+  ];
+  p.note(lines.join("\n"), "Next steps");
+  p.outro(`Problems or feedback? ${color.underline("https://github.com/mastra-ai/mastra/issues")}`);
+}
+function cancel2() {
+  p.cancel("Cancelled.");
+  process.exitCode = 1;
+}
+
+// src/index.ts
+var pkg = JSON.parse(
+  readFileSync2(path4.join(path4.dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8")
+);
+var analytics = new Analytics(pkg.version);
+var program = new Command();
+program.name("mastra-factory").description("Create a Mastra Software Factory project").version(pkg.version, "-v, --version").argument("[project-name]", "Directory name of the project").option("--default", "Non-interactive: default name, init git").option("--template-ref <ref>", "Pin a template repo tag/branch").option("--template-dir <dir>", "Use a local template directory instead of cloning (development)").option("-t, --timeout [ms]", "Timeout for dependency installation in ms").action(async (projectNameArg, args) => {
+  let timeout;
+  if (args.timeout !== void 0) {
+    timeout = args.timeout === true ? 6e4 : Number(args.timeout);
+    if (!Number.isInteger(timeout) || timeout <= 0) {
+      throw new Error(`--timeout must be a positive integer in milliseconds (got ${String(args.timeout)})`);
+    }
+  }
+  await create({
+    projectName: projectNameArg,
+    useDefaults: Boolean(args.default),
+    templateRef: args.templateRef ? String(args.templateRef) : void 0,
+    templateDir: args.templateDir ? String(args.templateDir) : void 0,
+    timeout,
+    analytics
+  });
+});
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exitCode = 1;
+} finally {
+  await analytics.shutdown(1e3);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "create-factory",
+  "version": "0.0.1",
+  "description": "Create a Mastra Software Factory project. Placeholder package claiming the name; use npx mastra-factory or npm create factory.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "bin": {
+    "create-factory": "./bin/cli.mjs"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mastra-ai/mastra.git",
+    "directory": "mastracode/mastra-factory"
+  },
+  "homepage": "https://mastra.ai",
+  "bugs": {
+    "url": "https://github.com/mastra-ai/mastra/issues"
+  },
+  "keywords": [
+    "mastra",
+    "software-factory",
+    "create",
+    "scaffold",
+    "cli",
+    "agents",
+    "ai"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "commander": "^14.0.3",
+    "picocolors": "^1.1.1",
+    "posthog-node": "^5.37.0"
+  }
+}