partweave 0.1.1

package/dist/chunk-2IGBGILB.js

@@ -0,0 +1,1230 @@
+#!/usr/bin/env node
+
+// src/commands/create.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { basename, resolve as resolve3 } from "path";
+import { intro, log, note, outro, spinner } from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/compose.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/inject.ts
+function anchorRegex(anchorId) {
+  return new RegExp(`^([ \\t]*).*<partweave:${escapeRe(anchorId)}>.*$`, "m");
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function injectAtAnchor(content, anchorId, lines) {
+  if (lines.length === 0) return { content, inserted: 0 };
+  const re = anchorRegex(anchorId);
+  const match = re.exec(content);
+  if (!match) {
+    throw new Error(`Anchor <partweave:${anchorId}> not found in target file`);
+  }
+  const indent = match[1] ?? "";
+  const existing = new Set(
+    content.split("\n").map((l) => l.trim()).filter(Boolean)
+  );
+  const toInsert = lines.filter((l) => !existing.has(l.trim()));
+  if (toInsert.length === 0) return { content, inserted: 0 };
+  const block = toInsert.map((l) => l ? indent + l : "").join("\n") + "\n";
+  const anchorStart = match.index;
+  const newContent = content.slice(0, anchorStart) + block + content.slice(anchorStart);
+  return { content: newContent, inserted: toInsert.length };
+}
+function parseDep(dep) {
+  const at = dep.lastIndexOf("@");
+  if (at > 0) {
+    return { name: dep.slice(0, at), version: dep.slice(at + 1) };
+  }
+  return { name: dep, version: "latest" };
+}
+function mergePackageJsonDeps(pkgJson, deps, field = "dependencies") {
+  if (deps.length === 0) return pkgJson;
+  const pkg = JSON.parse(pkgJson);
+  const bucket = pkg[field] ?? {};
+  for (const dep of deps) {
+    const { name, version } = parseDep(dep);
+    if (!(name in bucket)) bucket[name] = version;
+  }
+  pkg[field] = Object.fromEntries(
+    Object.entries(bucket).sort(([a], [b]) => a.localeCompare(b))
+  );
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function appendEnv(envBody, entries, heading) {
+  const keys = Object.keys(entries);
+  if (keys.length === 0) return envBody;
+  const present = new Set(
+    envBody.split("\n").map((l) => l.split("=")[0]?.trim()).filter(Boolean)
+  );
+  const missing = keys.filter((k) => !present.has(k));
+  if (missing.length === 0) return envBody;
+  let out = envBody.replace(/\n*$/, "\n");
+  if (heading) out += `
+# ${heading}
+`;
+  for (const k of missing) out += `${k}=${entries[k]}
+`;
+  return out;
+}
+
+// src/fsutil.ts
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, relative } from "path";
+
+// src/render.ts
+var TOKEN = /\{\{\s*([\w.]+)\s*\}\}/g;
+function buildScalars(ctx) {
+  return {
+    projectName: ctx.projectName,
+    projectSlug: ctx.projectSlug,
+    description: ctx.description,
+    // Java/Android package segments allow underscores but not hyphens.
+    packageId: "com.example." + ctx.projectSlug.replace(/-/g, "_"),
+    "apps.list": ctx.apps.join(", ")
+  };
+}
+function render(content, ctx) {
+  const scalars = buildScalars(ctx);
+  return content.replace(TOKEN, (whole, key) => {
+    if (Object.prototype.hasOwnProperty.call(scalars, key)) return scalars[key];
+    return whole;
+  });
+}
+var BINARY_EXT = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".ttf",
+  ".otf",
+  ".woff",
+  ".woff2",
+  ".pdf",
+  ".zip"
+]);
+function isBinaryPath(p) {
+  const dot = p.lastIndexOf(".");
+  if (dot === -1) return false;
+  return BINARY_EXT.has(p.slice(dot).toLowerCase());
+}
+function slugify(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+
+// src/fsutil.ts
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+function writeFileEnsured(p, content) {
+  ensureDir(dirname(p));
+  writeFileSync(p, content);
+}
+function listFiles(root) {
+  const out = [];
+  const walk = (dir) => {
+    for (const name of readdirSync(dir)) {
+      const abs = join(dir, name);
+      if (statSync(abs).isDirectory()) walk(abs);
+      else out.push(relative(root, abs));
+    }
+  };
+  if (existsSync(root)) walk(root);
+  return out;
+}
+function copyTree(srcRoot, destRoot, ctx) {
+  const written = [];
+  for (const rel of listFiles(srcRoot)) {
+    if (rel === "module.json") continue;
+    const src = join(srcRoot, rel);
+    const destRel = rel.replace(/(^|\/)_gitignore$/, "$1.gitignore");
+    const dest = join(destRoot, destRel);
+    ensureDir(dirname(dest));
+    if (isBinaryPath(src)) {
+      cpSync(src, dest);
+    } else {
+      writeFileSync(dest, render(readFileSync(src, "utf8"), ctx));
+    }
+    written.push(destRel);
+  }
+  return written;
+}
+
+// src/pm.ts
+import { spawnSync } from "child_process";
+var JS_PMS = ["pnpm", "npm"];
+var PY_PMS = ["uv", "pip"];
+var DEFAULT_JS_PM = "pnpm";
+var DEFAULT_PY_PM = "uv";
+var PNPM_VERSION = "pnpm@10.20.0";
+function jsPmProfile(name) {
+  if (name === "npm") {
+    return {
+      name,
+      install: "npm install",
+      run: (pkg, script) => `npm run ${script} -w ${pkg}`,
+      runAll: (script) => `npm run ${script} --workspaces --if-present`,
+      packageManagerField: null,
+      usesWorkspaceYaml: false,
+      needsHoistNpmrc: false
+    };
+  }
+  return {
+    name: "pnpm",
+    install: "pnpm install",
+    run: (pkg, script) => `pnpm --filter ${pkg} ${script}`,
+    runAll: (script) => `pnpm -r ${script}`,
+    packageManagerField: PNPM_VERSION,
+    usesWorkspaceYaml: true,
+    needsHoistNpmrc: true
+  };
+}
+var PIP_SYNC = "python3 -m venv .venv && .venv/bin/python -m pip install -U pip && .venv/bin/python scripts/sync_deps.py";
+function pyPmProfile(name) {
+  if (name === "pip") {
+    return {
+      name,
+      syncInServer: PIP_SYNC,
+      run: (cmd) => `.venv/bin/${cmd}`,
+      needsSyncScript: true
+    };
+  }
+  return {
+    name: "uv",
+    syncInServer: "uv sync",
+    run: (cmd) => `uv run ${cmd}`,
+    needsSyncScript: false
+  };
+}
+function hasCommand(cmd) {
+  try {
+    const probe = process.platform === "win32" ? spawnSync("where", [cmd], { stdio: "ignore" }) : spawnSync("sh", ["-c", `command -v ${cmd}`], { stdio: "ignore" });
+    return probe.status === 0;
+  } catch {
+    return false;
+  }
+}
+function detectJsPm() {
+  return hasCommand("pnpm") ? "pnpm" : "npm";
+}
+function detectPyPm() {
+  return hasCommand("uv") ? "uv" : "pip";
+}
+
+// src/rootgen.ts
+import { randomBytes } from "crypto";
+function jsMembers(ctx) {
+  const members = [];
+  if (ctx.hasWeb) members.push("apps/web");
+  if (ctx.hasMobile) members.push("apps/mobile");
+  if (ctx.hasShared) members.push("packages/shared");
+  if (ctx.hasApiClient) members.push("packages/api-client");
+  return members;
+}
+function buildJsWorkspace(ctx) {
+  if (!jsPmProfile(ctx.jsPm).usesWorkspaceYaml) return null;
+  const members = jsMembers(ctx);
+  if (members.length === 0) return null;
+  return "packages:\n" + members.map((m) => `  - "${m}"`).join("\n") + "\n";
+}
+function buildRootPackageJson(ctx) {
+  const anyJs = ctx.hasWeb || ctx.hasMobile || ctx.hasShared;
+  if (!anyJs) return null;
+  const pm = jsPmProfile(ctx.jsPm);
+  const scripts = {};
+  if (ctx.hasWeb) scripts["dev:web"] = pm.run("web", "dev");
+  if (ctx.hasMobile) scripts["dev:mobile"] = pm.run("mobile", "start");
+  if (ctx.hasApiClient) scripts["gen:api"] = pm.run("@app/api-client", "generate");
+  scripts["typecheck"] = pm.runAll("typecheck");
+  const pkg = {
+    name: ctx.projectSlug,
+    version: "0.1.0",
+    private: true
+  };
+  if (pm.packageManagerField) pkg.packageManager = pm.packageManagerField;
+  if (!pm.usesWorkspaceYaml) pkg.workspaces = jsMembers(ctx);
+  pkg.scripts = scripts;
+  pkg.devDependencies = { typescript: "^5.7.2" };
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function buildMakefile(ctx, hasDocker) {
+  const js = jsPmProfile(ctx.jsPm);
+  const py = pyPmProfile(ctx.pyPm);
+  const L = [];
+  const phony = [];
+  const add = (name, body, help) => {
+    phony.push(name);
+    L.push(`${name}: ## ${help}`);
+    for (const line of body) L.push(`	${line}`);
+    L.push("");
+  };
+  L.push("# " + ctx.projectName + " \u2014 dev tasks");
+  L.push(".DEFAULT_GOAL := help");
+  L.push("");
+  const bootstrap = [];
+  if (ctx.hasWeb || ctx.hasMobile || ctx.hasShared) bootstrap.push(js.install);
+  if (ctx.hasServer) bootstrap.push(`cd apps/server && ${py.syncInServer}`);
+  if (bootstrap.length) add("bootstrap", bootstrap, "install all dependencies");
+  if (ctx.hasServer) {
+    if (hasDocker) {
+      add(
+        "db-up",
+        [
+          `@docker info >/dev/null 2>&1 || { echo "Docker isn't running \u2014 start Docker Desktop and wait for it to be ready, then retry."; exit 1; }`,
+          // Load the project's .env (if present) so POSTGRES_* there drive the container.
+          "docker compose $$([ -f .env ] && echo --env-file .env) -f infra/docker-compose.yml up -d db"
+        ],
+        "start Postgres (needs Docker running)"
+      );
+      add("db-down", ["docker compose -f infra/docker-compose.yml down"], "stop Postgres");
+    }
+    add("migrate", [`cd apps/server && ${py.run("python manage.py migrate")}`], "run migrations");
+    add(
+      "server",
+      [`cd apps/server && ${py.run("python manage.py runserver 0.0.0.0:8000")}`],
+      "run the Django dev server"
+    );
+    add(
+      "superuser",
+      [`cd apps/server && ${py.run("python manage.py createsuperuser")}`],
+      "create an admin user"
+    );
+  }
+  if (ctx.hasWeb) add("web", [js.run("web", "dev")], "run the Next.js dev server");
+  if (ctx.hasMobile) add("mobile", [js.run("mobile", "start")], "run the Expo dev server");
+  if (ctx.hasApiClient)
+    add("gen-api", [js.run("@app/api-client", "generate")], "regenerate the typed API client");
+  L.push(
+    "help: ## show this help",
+    `	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  \\033[36m%-12s\\033[0m %s\\n", $$1, $$2}'`,
+    "",
+    ".PHONY: " + [...phony, "help"].join(" "),
+    ""
+  );
+  return L.join("\n");
+}
+function buildTurboJson(ctx) {
+  if (!(ctx.hasWeb || ctx.hasMobile || ctx.hasShared)) return null;
+  return JSON.stringify(
+    {
+      $schema: "https://turbo.build/schema.json",
+      tasks: {
+        build: { dependsOn: ["^build"], outputs: ["dist/**", ".next/**"] },
+        dev: { cache: false, persistent: true },
+        typecheck: { dependsOn: ["^build"] },
+        lint: {}
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function buildTsconfigBase(ctx) {
+  if (!(ctx.hasWeb || ctx.hasMobile || ctx.hasShared)) return null;
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        lib: ["ES2023"],
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        resolveJsonModule: true,
+        isolatedModules: true
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function buildNpmrc(ctx) {
+  if (!ctx.hasMobile) return null;
+  if (!jsPmProfile(ctx.jsPm).needsHoistNpmrc) return null;
+  return [
+    "# Expo / React Native need a flat node_modules layout.",
+    "node-linker=hoisted",
+    "shamefully-hoist=true",
+    ""
+  ].join("\n");
+}
+function buildBaseEnv(ctx) {
+  const lines = [
+    "# Environment for " + ctx.projectName,
+    "#",
+    "# Every value the app reads from the environment lives here. Copy this file to",
+    "# `.env` and adjust as needed \u2014 the server, web/mobile apps, and each component",
+    "# read their configuration from it, so there's nothing to configure elsewhere.",
+    ""
+  ];
+  if (ctx.hasServer) {
+    lines.push(
+      "# --- server ---",
+      "# Unique per-project key generated at scaffold time; signs sessions and JWTs.",
+      "# Use a separate secret value in production (and never commit the real one).",
+      `DJANGO_SECRET_KEY=${randomBytes(48).toString("base64url")}`,
+      "DJANGO_DEBUG=true",
+      "DJANGO_ALLOWED_HOSTS=localhost,127.0.0.1",
+      "# Web origins allowed to call the API when DEBUG is off (comma-separated).",
+      "# In DEBUG every origin is allowed, so this is only needed in production.",
+      "# DJANGO_CORS_ALLOWED_ORIGINS=https://app.example.com",
+      "# DATABASE_URL \u2014 the server uses local SQLite by default; set a database URL",
+      "# to switch (the `db-postgres` component sets a Postgres DSN here for you).",
+      ""
+    );
+  }
+  if (ctx.hasWeb) {
+    lines.push("# --- web ---", "NEXT_PUBLIC_API_URL=http://localhost:8000", "");
+  }
+  if (ctx.hasMobile) {
+    lines.push(
+      "# --- mobile (Expo) ---",
+      "# In dev the app auto-detects your machine's LAN IP so a physical device can",
+      "# reach the server \u2014 leave this unset. Set it for simulators or production,",
+      "# in the environment or apps/mobile/.env (Expo reads EXPO_PUBLIC_* from there).",
+      "# EXPO_PUBLIC_API_URL=http://localhost:8000",
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+function jsCiSteps(ctx) {
+  if (ctx.jsPm === "npm") {
+    return `      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm install`;
+  }
+  return `      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile`;
+}
+function serverCiSteps(ctx) {
+  const py = pyPmProfile(ctx.pyPm);
+  if (ctx.pyPm === "pip") {
+    return `      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: ${py.syncInServer}
+      - run: ${py.run("ruff check .")}
+      - run: ${py.run("python manage.py migrate")}
+      - run: ${py.run("pytest -q")}`;
+  }
+  return `      - uses: astral-sh/setup-uv@v5
+      - run: ${py.syncInServer}
+      - run: ${py.run("ruff check .")}
+      - run: ${py.run("python manage.py migrate")}
+      - run: ${py.run("pytest -q")}`;
+}
+function buildCiWorkflows(ctx) {
+  const js = jsPmProfile(ctx.jsPm);
+  const out = {};
+  if (ctx.hasServer) {
+    out[".github/workflows/server.yml"] = `name: server
+on:
+  push:
+    paths: ["apps/server/**", ".github/workflows/server.yml"]
+  pull_request:
+    paths: ["apps/server/**", ".github/workflows/server.yml"]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/server
+    steps:
+      - uses: actions/checkout@v4
+${serverCiSteps(ctx)}
+`;
+  }
+  if (ctx.hasWeb) {
+    out[".github/workflows/web.yml"] = `name: web
+on:
+  push:
+    paths: ["apps/web/**", "packages/**", ".github/workflows/web.yml"]
+  pull_request:
+    paths: ["apps/web/**", "packages/**", ".github/workflows/web.yml"]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+${jsCiSteps(ctx)}
+      - run: ${js.run("web", "typecheck")}
+      - run: ${js.run("web", "build")}
+`;
+  }
+  if (ctx.hasMobile) {
+    out[".github/workflows/mobile.yml"] = `name: mobile
+on:
+  push:
+    paths: ["apps/mobile/**", "packages/**", ".github/workflows/mobile.yml"]
+  pull_request:
+    paths: ["apps/mobile/**", "packages/**", ".github/workflows/mobile.yml"]
+jobs:
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+${jsCiSteps(ctx)}
+      - run: ${js.run("mobile", "typecheck")}
+`;
+  }
+  return out;
+}
+function buildReadme(ctx, modules) {
+  const parts = [];
+  parts.push(`# ${ctx.projectName}`, "", ctx.description, "");
+  parts.push("Generated with **partweave** \u2014 a modular full-stack scaffolder.", "");
+  parts.push("## What's inside", "");
+  if (ctx.hasServer) parts.push(`- \`apps/server\` \u2014 Django + DRF API (managed by \`${ctx.pyPm}\`)`);
+  if (ctx.hasWeb) parts.push("- `apps/web` \u2014 Next.js web app");
+  if (ctx.hasMobile) parts.push("- `apps/mobile` \u2014 Expo (React Native) app");
+  if (ctx.hasShared) parts.push("- `packages/shared` \u2014 shared TypeScript interfaces & schemas");
+  if (ctx.hasApiClient) parts.push("- `packages/api-client` \u2014 typed client generated from the API's OpenAPI schema");
+  parts.push("");
+  if (modules.length) {
+    parts.push("### Components", "");
+    for (const m of modules) parts.push(`- **${m.manifest.title}** \u2014 ${m.manifest.description ?? ""}`);
+    parts.push("");
+  }
+  parts.push("## Getting started", "", "```sh", "make bootstrap");
+  if (ctx.hasServer) parts.push("make db-up && make migrate", "make server   # http://localhost:8000");
+  if (ctx.hasWeb) parts.push("make web      # http://localhost:3000");
+  if (ctx.hasMobile) parts.push("make mobile   # Expo dev server");
+  parts.push("```", "");
+  parts.push("Copy `.env.example` to `.env` and fill in values before running.", "");
+  return parts.join("\n");
+}
+function buildServerDockerfile(ctx) {
+  if (ctx.pyPm === "pip") {
+    return `# Production image for the Django server (pip / venv).
+FROM python:3.12-slim
+
+ENV PYTHONUNBUFFERED=1 \\
+    PYTHONDONTWRITEBYTECODE=1
+
+WORKDIR /app
+
+COPY . .
+RUN python3 -m venv .venv \\
+    && .venv/bin/python -m pip install -U pip \\
+    && .venv/bin/python scripts/sync_deps.py --no-dev
+
+EXPOSE 8000
+CMD [".venv/bin/gunicorn", "config.wsgi:application", "--bind", "0.0.0.0:8000"]
+`;
+  }
+  return `# Production image for the Django server, built with uv.
+FROM python:3.12-slim
+
+ENV PYTHONUNBUFFERED=1 \\
+    PYTHONDONTWRITEBYTECODE=1 \\
+    UV_COMPILE_BYTECODE=1 \\
+    UV_LINK_MODE=copy
+
+WORKDIR /app
+
+# uv binary from the official distroless image
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+COPY . .
+RUN uv sync --no-dev
+
+EXPOSE 8000
+CMD ["uv", "run", "gunicorn", "config.wsgi:application", "--bind", "0.0.0.0:8000"]
+`;
+}
+function buildPipSyncScript(ctx) {
+  if (!ctx.hasServer || !pyPmProfile(ctx.pyPm).needsSyncScript) return null;
+  return `#!/usr/bin/env python3
+"""Install this app's dependencies from pyproject.toml into the active venv.
+
+The pip/venv counterpart to \`uv sync\`. Run it (via the venv's Python) after
+adding a component so new dependencies are picked up:
+
+    .venv/bin/python scripts/sync_deps.py          # runtime + dev deps
+    .venv/bin/python scripts/sync_deps.py --no-dev # runtime deps only (prod)
+"""
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+no_dev = "--no-dev" in sys.argv[1:]
+pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
+data = tomllib.loads(pyproject.read_text())
+deps = list(data.get("project", {}).get("dependencies", []))
+if not no_dev:
+    deps += data.get("dependency-groups", {}).get("dev", [])
+if deps:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", *deps])
+`;
+}
+
+// src/types.ts
+import { z } from "zod";
+var TARGETS = [
+  "root",
+  "server",
+  "web",
+  "mobile",
+  "shared",
+  "api-client"
+];
+var TARGET_DEST = {
+  root: ".",
+  server: "apps/server",
+  web: "apps/web",
+  mobile: "apps/mobile",
+  shared: "packages/shared",
+  "api-client": "packages/api-client"
+};
+var APPS = ["server", "web", "mobile"];
+var WiringForTargetSchema = z.object({
+  installedApps: z.array(z.string()).optional(),
+  // server → <partweave:installed-apps>
+  urls: z.array(z.string()).optional(),
+  // server → <partweave:urls>
+  settings: z.array(z.string()).optional(),
+  // server → <partweave:settings>
+  providers: z.array(z.string()).optional(),
+  // web/mobile → <partweave:providers>
+  routes: z.array(z.string()).optional(),
+  // web/mobile → <partweave:routes>
+  deps: z.array(z.string()).optional(),
+  // merged into pyproject/package.json
+  anchors: z.record(z.array(z.string())).optional()
+  // generic anchorId → lines
+});
+var CONVENIENCE_ANCHORS = {
+  installedApps: "installed-apps",
+  urls: "urls",
+  settings: "settings",
+  providers: "providers",
+  routes: "routes"
+};
+var ManifestSchema = z.object({
+  id: z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "id must be kebab-case"),
+  title: z.string(),
+  description: z.string().optional(),
+  /** "app" = a top-level toggle (server/web/mobile); "feature" = a component. */
+  kind: z.enum(["app", "feature"]).default("feature"),
+  /** which target sub-projects this module contributes to */
+  targets: z.array(z.enum(TARGETS)).min(1),
+  /** apps that MUST be selected for this module to work (e.g. auth needs server) */
+  requiresApps: z.array(z.enum(APPS)).default([]),
+  /** modules that must also be present (auto-selected) */
+  requires: z.array(z.string()).default([]),
+  /** modules that cannot coexist with this one */
+  conflicts: z.array(z.string()).default([]),
+  /** capability/interface this module satisfies (for conflict grouping) */
+  provides: z.string().optional(),
+  /** env keys → default value, appended to .env.example */
+  env: z.record(z.string()).default({}),
+  /** per-target wiring (files are copied separately from wiring injection) */
+  wiring: z.record(z.enum(TARGETS), WiringForTargetSchema).default({}),
+  /** whether this module is offered by default in the interactive picker */
+  default: z.boolean().default(false),
+  /** notes printed after generation */
+  notes: z.array(z.string()).default([])
+});
+
+// src/compose.ts
+function buildContext(selection) {
+  const hasServer = selection.apps.includes("server");
+  const hasWeb = selection.apps.includes("web");
+  const hasMobile = selection.apps.includes("mobile");
+  const hasShared = hasWeb || hasMobile;
+  const hasApiClient = hasServer && (hasWeb || hasMobile);
+  return {
+    projectName: selection.projectName,
+    projectSlug: slugify(selection.projectName),
+    description: `${selection.projectName} \u2014 generated with partweave.`,
+    apps: selection.apps,
+    hasServer,
+    hasWeb,
+    hasMobile,
+    hasShared,
+    hasApiClient,
+    jsPm: selection.jsPm ?? DEFAULT_JS_PM,
+    pyPm: selection.pyPm ?? DEFAULT_PY_PM
+  };
+}
+function selectedTargets(ctx) {
+  const t = /* @__PURE__ */ new Set(["root"]);
+  if (ctx.hasServer) t.add("server");
+  if (ctx.hasWeb) t.add("web");
+  if (ctx.hasMobile) t.add("mobile");
+  if (ctx.hasShared) t.add("shared");
+  if (ctx.hasApiClient) t.add("api-client");
+  return t;
+}
+var COPY_ORDER = [
+  "root",
+  "server",
+  "web",
+  "mobile",
+  "shared",
+  "api-client"
+];
+function buildAnchorIndex(dir) {
+  const index = /* @__PURE__ */ new Map();
+  const re = /<partweave:([\w-]+)>/g;
+  for (const rel of listFiles(dir)) {
+    const abs = join2(dir, rel);
+    if (isBinaryPath(abs)) continue;
+    const content = readFileSync2(abs, "utf8");
+    let m;
+    while (m = re.exec(content)) {
+      const id = m[1];
+      const arr = index.get(id) ?? [];
+      if (!arr.includes(abs)) arr.push(abs);
+      index.set(id, arr);
+    }
+  }
+  return index;
+}
+function anchorInjections(w) {
+  const out = {};
+  const push = (anchor, lines) => {
+    if (!lines?.length) return;
+    out[anchor] = [...out[anchor] ?? [], ...lines];
+  };
+  for (const [field, anchor] of Object.entries(CONVENIENCE_ANCHORS)) {
+    push(anchor, w[field]);
+  }
+  if (w.anchors) for (const [a, lines] of Object.entries(w.anchors)) push(a, lines);
+  return out;
+}
+function injectIntoFiles(index, anchorId, lines, targetLabel) {
+  const files = index.get(anchorId);
+  if (!files || files.length === 0) {
+    throw new Error(
+      `Wiring error: anchor <partweave:${anchorId}> not found in ${targetLabel}. Add the anchor to the _core/${targetLabel} scaffold.`
+    );
+  }
+  for (const file of files) {
+    const content = readFileSync2(file, "utf8");
+    const { content: next } = injectAtAnchor(content, anchorId, lines);
+    writeFileSync2(file, next);
+  }
+}
+function applyWiring(outDir, targets, modules) {
+  const indexes = /* @__PURE__ */ new Map();
+  for (const t of targets) {
+    indexes.set(t, buildAnchorIndex(join2(outDir, TARGET_DEST[t])));
+  }
+  for (const mod of modules) {
+    for (const t of mod.manifest.targets) {
+      if (!targets.has(t)) continue;
+      const wiring = mod.manifest.wiring[t];
+      if (!wiring) continue;
+      const index = indexes.get(t);
+      const targetDir = join2(outDir, TARGET_DEST[t]);
+      for (const [anchor, lines] of Object.entries(anchorInjections(wiring))) {
+        injectIntoFiles(index, anchor, lines, t);
+      }
+      if (wiring.deps?.length) {
+        if (t === "server") {
+          const lines = wiring.deps.map((d) => `"${d}",`);
+          injectIntoFiles(index, "deps", lines, t);
+        } else {
+          const pkgPath = join2(targetDir, "package.json");
+          if (existsSync2(pkgPath)) {
+            const merged = mergePackageJsonDeps(
+              readFileSync2(pkgPath, "utf8"),
+              wiring.deps
+            );
+            writeFileSync2(pkgPath, merged);
+          }
+        }
+      }
+    }
+  }
+}
+function applyEnv(outDir, modules) {
+  const envPath = join2(outDir, ".env.example");
+  let body = existsSync2(envPath) ? readFileSync2(envPath, "utf8") : "";
+  for (const mod of modules) {
+    if (Object.keys(mod.manifest.env).length === 0) continue;
+    body = appendEnv(body, mod.manifest.env, mod.manifest.title);
+  }
+  if (body) writeFileSync2(envPath, body);
+}
+function writeStructuralRootFiles(outDir, ctx, modules) {
+  const workspace = buildJsWorkspace(ctx);
+  if (workspace) writeFileEnsured(join2(outDir, "pnpm-workspace.yaml"), workspace);
+  const rootPkg = buildRootPackageJson(ctx);
+  if (rootPkg) writeFileEnsured(join2(outDir, "package.json"), rootPkg);
+  const turbo = buildTurboJson(ctx);
+  if (turbo) writeFileEnsured(join2(outDir, "turbo.json"), turbo);
+  const tsbase = buildTsconfigBase(ctx);
+  if (tsbase) writeFileEnsured(join2(outDir, "tsconfig.base.json"), tsbase);
+  const npmrc = buildNpmrc(ctx);
+  if (npmrc) writeFileEnsured(join2(outDir, ".npmrc"), npmrc);
+  const pipSync = buildPipSyncScript(ctx);
+  if (pipSync) writeFileEnsured(join2(outDir, "apps/server/scripts/sync_deps.py"), pipSync);
+  const hasDocker = modules.some((m) => m.manifest.id === "docker");
+  writeFileEnsured(join2(outDir, "Makefile"), buildMakefile(ctx, hasDocker));
+  writeFileEnsured(join2(outDir, ".env.example"), buildBaseEnv(ctx));
+}
+function compose(opts) {
+  const { selection, registry, scaffoldTargets, wireTargets, rootFiles } = opts;
+  const ctx = buildContext(selection);
+  const outDir = selection.outDir;
+  const modules = selection.modules.map((id) => registry.require(id));
+  const written = [];
+  for (const t of COPY_ORDER) {
+    if (!scaffoldTargets.has(t)) continue;
+    const src = join2(registry.modulesDir, "_core", t);
+    if (existsSync2(src)) {
+      written.push(...copyTree(src, join2(outDir, TARGET_DEST[t]), ctx));
+    }
+  }
+  if (rootFiles !== "none") writeStructuralRootFiles(outDir, ctx, modules);
+  if (rootFiles === "all") {
+    writeFileEnsured(join2(outDir, "README.md"), buildReadme(ctx, modules));
+  }
+  for (const mod of modules) {
+    for (const t of mod.manifest.targets) {
+      if (!wireTargets.has(t)) continue;
+      const src = join2(mod.dir, t);
+      if (existsSync2(src)) {
+        written.push(...copyTree(src, join2(outDir, TARGET_DEST[t]), ctx));
+      }
+    }
+  }
+  applyWiring(outDir, wireTargets, modules);
+  applyEnv(outDir, modules);
+  if (selection.modules.includes("ci")) {
+    for (const [rel, content] of Object.entries(buildCiWorkflows(ctx))) {
+      writeFileEnsured(join2(outDir, rel), content);
+      written.push(rel);
+    }
+  }
+  if (selection.modules.includes("docker") && ctx.hasServer) {
+    const rel = "apps/server/Dockerfile";
+    writeFileEnsured(join2(outDir, rel), buildServerDockerfile(ctx));
+    written.push(rel);
+  }
+  const notes = modules.flatMap((m) => m.manifest.notes);
+  return { written, notes };
+}
+
+// src/registry.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
+
+// src/paths.ts
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname2, join as join3, resolve } from "path";
+import { fileURLToPath } from "url";
+var here = dirname2(fileURLToPath(import.meta.url));
+function findModulesDir() {
+  const override = process.env.PARTWEAVE_MODULES_DIR;
+  if (override) {
+    const abs = resolve(override);
+    if (existsSync3(join3(abs, "_core"))) return abs;
+    throw new Error(`PARTWEAVE_MODULES_DIR=${override} has no _core/ inside it`);
+  }
+  let cur = here;
+  for (let i = 0; i < 8; i++) {
+    const candidate = join3(cur, "modules");
+    if (existsSync3(join3(candidate, "_core"))) return candidate;
+    const parent = dirname2(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  throw new Error(
+    "Could not locate the modules/ catalog. Set PARTWEAVE_MODULES_DIR to point at it."
+  );
+}
+
+// src/registry.ts
+var Registry = class {
+  modulesDir;
+  byId = /* @__PURE__ */ new Map();
+  constructor(modulesDir = findModulesDir()) {
+    this.modulesDir = modulesDir;
+    this.load();
+  }
+  load() {
+    for (const name of readdirSync2(this.modulesDir)) {
+      if (name === "_core" || name.startsWith(".")) continue;
+      const dir = join4(this.modulesDir, name);
+      if (!statSync2(dir).isDirectory()) continue;
+      const manifestPath = join4(dir, "module.json");
+      let raw;
+      try {
+        raw = JSON.parse(readFileSync3(manifestPath, "utf8"));
+      } catch {
+        throw new Error(`Module "${name}" is missing a valid module.json`);
+      }
+      const parsed = ManifestSchema.safeParse(raw);
+      if (!parsed.success) {
+        throw new Error(
+          `Invalid module.json for "${name}":
+${parsed.error.toString()}`
+        );
+      }
+      if (parsed.data.id !== name) {
+        throw new Error(
+          `Module dir "${name}" does not match manifest id "${parsed.data.id}"`
+        );
+      }
+      this.byId.set(parsed.data.id, { manifest: parsed.data, dir });
+    }
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  require(id) {
+    const m = this.byId.get(id);
+    if (!m) throw new Error(`Unknown module: "${id}"`);
+    return m;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  all() {
+    return [...this.byId.values()];
+  }
+  /** Feature modules (not app-kind), sorted for stable display. */
+  features() {
+    return this.all().filter((m) => m.manifest.kind === "feature").sort((a, b) => a.manifest.id.localeCompare(b.manifest.id));
+  }
+};
+
+// src/projectmanifest.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+var REL = ".partweave/manifest.json";
+function readProjectManifest(dir) {
+  const p = join5(dir, REL);
+  if (!existsSync4(p)) return null;
+  try {
+    return JSON.parse(readFileSync4(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeProjectManifest(dir, pm) {
+  writeFileEnsured(join5(dir, REL), JSON.stringify(pm, null, 2) + "\n");
+}
+
+// src/resolve.ts
+function resolveModules(registry, chosen) {
+  const requested = new Set(chosen);
+  const resolved = /* @__PURE__ */ new Set();
+  const autoAdded = /* @__PURE__ */ new Set();
+  const visit = (id, stack) => {
+    if (resolved.has(id)) return;
+    if (stack.includes(id)) {
+      throw new Error(
+        `Circular module dependency: ${[...stack, id].join(" \u2192 ")}`
+      );
+    }
+    const mod = registry.get(id);
+    if (!mod) {
+      throw new Error(`Unknown module: "${id}"`);
+    }
+    for (const dep of mod.manifest.requires) {
+      if (!requested.has(dep)) autoAdded.add(dep);
+      visit(dep, [...stack, id]);
+    }
+    resolved.add(id);
+  };
+  for (const id of chosen) visit(id, []);
+  const provided = /* @__PURE__ */ new Map();
+  for (const id of resolved) {
+    const mod = registry.require(id);
+    for (const c of mod.manifest.conflicts) {
+      if (resolved.has(c)) {
+        throw new Error(`Modules "${id}" and "${c}" conflict and cannot both be selected.`);
+      }
+    }
+    const cap = mod.manifest.provides;
+    if (cap) {
+      const other = provided.get(cap);
+      if (other && other !== id) {
+        throw new Error(
+          `Modules "${id}" and "${other}" both provide "${cap}"; pick one.`
+        );
+      }
+      provided.set(cap, id);
+    }
+  }
+  const order = [...resolved].sort((a, b) => {
+    const da = registry.require(a).manifest.requires.length;
+    const db = registry.require(b).manifest.requires.length;
+    return da - db || a.localeCompare(b);
+  });
+  return { modules: order, autoAdded: [...autoAdded].sort() };
+}
+function validateApps(registry, moduleIds, apps) {
+  const have = new Set(apps);
+  const problems = [];
+  for (const id of moduleIds) {
+    const mod = registry.require(id);
+    for (const app of mod.manifest.requiresApps) {
+      if (!have.has(app)) {
+        problems.push(`"${mod.manifest.id}" needs the ${app} app`);
+      }
+    }
+  }
+  if (problems.length) {
+    throw new Error(
+      `Incompatible selection:
+  - ${problems.join("\n  - ")}
+Enable the required app(s) or drop the component(s).`
+    );
+  }
+}
+
+// src/prompts.ts
+import {
+  cancel,
+  confirm,
+  isCancel,
+  multiselect,
+  select,
+  text
+} from "@clack/prompts";
+import pc from "picocolors";
+import { resolve as resolve2 } from "path";
+var MULTI_HINT = pc.dim("\u2191/\u2193 move \xB7 space toggle \xB7 a all \xB7 enter confirm");
+function bail(v) {
+  if (isCancel(v)) {
+    cancel("Cancelled.");
+    process.exit(0);
+  }
+}
+async function promptCreate(registry, defaults) {
+  const nameRaw = await text({
+    message: "Project name",
+    placeholder: "my-project",
+    initialValue: defaults.projectName ?? "",
+    validate: (v) => v.trim() ? void 0 : "Required"
+  });
+  bail(nameRaw);
+  const projectName = nameRaw.trim();
+  const dirRaw = await text({
+    message: "Target directory",
+    initialValue: defaults.outDir ?? `./${slugify(projectName)}`,
+    validate: (v) => v.trim() ? void 0 : "Required"
+  });
+  bail(dirRaw);
+  const outDir = resolve2(dirRaw.trim());
+  const appsRaw = await multiselect({
+    message: `Which apps?  ${MULTI_HINT}`,
+    options: [
+      { value: "server", label: "Server", hint: "Django + DRF" },
+      { value: "web", label: "Web", hint: "Next.js" },
+      { value: "mobile", label: "Mobile", hint: "Expo / React Native" }
+    ],
+    initialValues: defaults.apps ?? [...APPS],
+    required: true
+  });
+  bail(appsRaw);
+  const apps = appsRaw;
+  const present = new Set(apps);
+  if (apps.includes("web") || apps.includes("mobile")) present.add("shared");
+  const relevant = registry.features().filter((m) => m.manifest.targets.some((t) => present.has(t))).filter((m) => m.manifest.requiresApps.every((a) => apps.includes(a)));
+  let modules = [];
+  if (relevant.length) {
+    const modsRaw = await multiselect({
+      message: `Which components? (deps auto-added)  ${MULTI_HINT}`,
+      options: relevant.map((m) => ({
+        value: m.manifest.id,
+        label: m.manifest.title,
+        hint: m.manifest.description
+      })),
+      initialValues: relevant.filter((m) => m.manifest.default).map((m) => m.manifest.id),
+      required: false
+    });
+    bail(modsRaw);
+    modules = modsRaw;
+  }
+  const anyJs = apps.includes("web") || apps.includes("mobile");
+  let jsPm = defaults.jsPm ?? detectJsPm();
+  if (anyJs) {
+    const jsRaw = await select({
+      message: "JS/TS package manager",
+      initialValue: jsPm,
+      options: [
+        { value: "pnpm", label: "pnpm", hint: hasCommand("pnpm") ? "detected" : "not found on PATH" },
+        { value: "npm", label: "npm", hint: "ships with Node" }
+      ]
+    });
+    bail(jsRaw);
+    jsPm = jsRaw;
+  }
+  let pyPm = defaults.pyPm ?? detectPyPm();
+  if (apps.includes("server")) {
+    const pyRaw = await select({
+      message: "Python package manager (server)",
+      initialValue: pyPm,
+      options: [
+        { value: "uv", label: "uv", hint: hasCommand("uv") ? "detected \xB7 fast" : "not found on PATH" },
+        { value: "pip", label: "pip + venv", hint: "ships with Python" }
+      ]
+    });
+    bail(pyRaw);
+    pyPm = pyRaw;
+  }
+  const ok = await confirm({
+    message: `Scaffold ${apps.join(" + ")}${modules.length ? " with " + modules.join(", ") : ""} into ${outDir}?`
+  });
+  bail(ok);
+  if (!ok) {
+    cancel("Cancelled.");
+    process.exit(0);
+  }
+  return { projectName, outDir, apps, modules, jsPm, pyPm };
+}
+
+// src/commands/create.ts
+function resolvePm(value, allowed, detect, flag) {
+  if (value === void 0) return detect();
+  if (allowed.includes(value)) return value;
+  log.error(`Invalid ${flag} "${value}". Choose one of: ${allowed.join(", ")}.`);
+  process.exit(1);
+}
+function appsFromFlags(flags) {
+  const explicit = ["server", "web", "mobile"].some(
+    (k) => flags[k] !== void 0
+  );
+  if (!explicit) return null;
+  const apps = APPS.filter((a) => flags[a] === true);
+  if (apps.length === 0) return APPS.filter((a) => flags[a] !== false);
+  return apps;
+}
+function defaultModules(registry, apps) {
+  const present = new Set(apps);
+  if (apps.includes("web") || apps.includes("mobile")) present.add("shared");
+  return registry.features().filter((m) => m.manifest.default).filter((m) => m.manifest.targets.some((t) => present.has(t))).filter((m) => m.manifest.requiresApps.every((a) => apps.includes(a))).map((m) => m.manifest.id);
+}
+async function runCreate(flags) {
+  intro(pc2.bgCyan(pc2.black(" partweave ")) + pc2.dim(" full-stack scaffolder"));
+  const registry = new Registry();
+  const flagApps = appsFromFlags(flags);
+  const nonInteractive = flags.yes === true || flagApps !== null;
+  const jsPm = resolvePm(flags.jsPm, JS_PMS, detectJsPm, "--js-pm");
+  const pyPm = resolvePm(flags.pyPm, PY_PMS, detectPyPm, "--py-pm");
+  let choices;
+  if (nonInteractive) {
+    const apps = flagApps ?? [...APPS];
+    const name = flags.name ?? "my-app";
+    const outDir = resolve3(flags.dir ?? `./${slugify(name)}`);
+    const modules = flags.with !== void 0 ? flags.with.split(",").map((s2) => s2.trim()).filter(Boolean) : defaultModules(registry, apps);
+    choices = { projectName: name, outDir, apps, modules, jsPm, pyPm };
+  } else {
+    choices = await promptCreate(registry, {
+      projectName: flags.name,
+      outDir: flags.dir ? resolve3(flags.dir) : void 0,
+      // pre-select an explicitly-passed --js-pm/--py-pm; otherwise the prompt
+      // defaults to whatever is installed.
+      jsPm: flags.jsPm ? jsPm : void 0,
+      pyPm: flags.pyPm ? pyPm : void 0
+    });
+  }
+  if (existsSync5(choices.outDir) && readdirSync3(choices.outDir).length > 0 && !flags.force) {
+    log.error(`${choices.outDir} exists and is not empty. Use --force to override.`);
+    process.exit(1);
+  }
+  let resolved;
+  try {
+    resolved = resolveModules(registry, choices.modules);
+  } catch (err) {
+    log.error(err.message);
+    process.exit(1);
+  }
+  if (resolved.autoAdded.length) {
+    log.info(`Added required components: ${resolved.autoAdded.join(", ")}`);
+  }
+  try {
+    validateApps(registry, resolved.modules, choices.apps);
+  } catch (err) {
+    log.error(err.message);
+    process.exit(1);
+  }
+  const s = spinner();
+  s.start("Scaffolding");
+  let result;
+  try {
+    const selection = {
+      projectName: choices.projectName,
+      outDir: choices.outDir,
+      apps: choices.apps,
+      modules: resolved.modules,
+      jsPm: choices.jsPm,
+      pyPm: choices.pyPm
+    };
+    const targets = selectedTargets(buildContext(selection));
+    result = compose({
+      selection,
+      registry,
+      scaffoldTargets: targets,
+      wireTargets: targets,
+      rootFiles: "all"
+    });
+  } catch (err) {
+    s.stop("Failed");
+    log.error(err.message);
+    process.exit(1);
+  }
+  s.stop(`Created ${result.written.length} files`);
+  writeProjectManifest(choices.outDir, {
+    name: choices.projectName,
+    apps: choices.apps,
+    modules: resolved.modules,
+    jsPm: choices.jsPm,
+    pyPm: choices.pyPm
+  });
+  const rel = basename(choices.outDir);
+  const steps = [`cd ${rel}`, "make bootstrap"];
+  if (choices.apps.includes("server")) steps.push("make db-up && make migrate", "make server");
+  if (choices.apps.includes("web")) steps.push("make web");
+  if (choices.apps.includes("mobile")) steps.push("make mobile");
+  note(steps.join("\n"), "Next steps");
+  if (result.notes.length) note(result.notes.join("\n"), "Notes");
+  outro(pc2.green("Done."));
+}
+
+export {
+  DEFAULT_JS_PM,
+  DEFAULT_PY_PM,
+  jsPmProfile,
+  pyPmProfile,
+  APPS,
+  buildContext,
+  selectedTargets,
+  compose,
+  Registry,
+  readProjectManifest,
+  writeProjectManifest,
+  resolveModules,
+  validateApps,
+  runCreate
+};
+//# sourceMappingURL=chunk-2IGBGILB.js.map