swallowkit 1.0.0-beta.8 → 1.0.0

package/src/utils/package-manager.ts

@@ -30,13 +30,13 @@ export interface PackageManagerCommands {
   dlx: string;
   /** Run a script: "pnpm run" / "npm run" */
   run: string;
-  /** Run a script with filter: "pnpm run --filter <ws>" / "npm run --workspace=<ws>" */
+  /** Run a script with filter: "pnpm --filter <ws> run" / "npm run --workspace=<ws>" */
   runFilter: (workspace: string) => string;
   /** Start script: "pnpm start" / "npm start" */
   start: string;
   /** Install production only (in temp dir for CI): "pnpm install --prod" / "npm install --omit=dev" */
   installProd: string;
-  /** create-next-app flag: "--use-pnpm" / (none for npm) */
+  /** create-next-app flag: "--use-pnpm" / "--use-npm" */
   createNextAppFlag: string | null;
 }
 
@@ -55,9 +55,9 @@ export function getCommands(pm: PackageManager): PackageManagerCommands {
       exec: "pnpm exec",
       dlx: "pnpm dlx",
       run: "pnpm run",
-      runFilter: (ws) => `pnpm run --filter ${ws}`,
+      runFilter: (ws) => `pnpm --filter ${ws} run`,
       start: "pnpm start",
-      installProd: "pnpm install --prod",
+      installProd: "pnpm install --prod --no-frozen-lockfile",
       createNextAppFlag: "--use-pnpm",
     };
   }
@@ -76,23 +76,20 @@ export function getCommands(pm: PackageManager): PackageManagerCommands {
     runFilter: (ws) => `npm run --workspace=${ws}`,
     start: "npm start",
     installProd: "npm install --omit=dev",
-    createNextAppFlag: null,
+    createNextAppFlag: "--use-npm",
   };
 }
 
 /**
  * Detect the preferred package manager for new project initialisation.
  *
- * Strategy (pnpm-preferred):
- *   1. If pnpm is installed on the system → always use pnpm
- *      (even when invoked via `npx`, since `npx` is often used out of habit)
- *   2. Otherwise → npm
- *
- * This is intentionally independent of `npm_config_user_agent` so that
- * `npx swallowkit init` still creates a pnpm project when pnpm is available.
+ * Honor the invoking package manager before falling back to available binaries.
  */
-export function detectFromUserAgent(): PackageManager {
-  return isPnpmInstalled() ? "pnpm" : "npm";
+export function detectFromUserAgent(pnpmIsInstalled: () => boolean = isPnpmInstalled): PackageManager {
+  const agent = process.env.npm_config_user_agent || "";
+  if (agent.startsWith("pnpm/")) return "pnpm";
+  if (agent.startsWith("npm/")) return "npm";
+  return pnpmIsInstalled() ? "pnpm" : "npm";
 }
 
 /**
@@ -111,11 +108,18 @@ function isPnpmInstalled(): boolean {
  * Detect the package manager used in an existing project directory
  * by checking for lockfiles.
  *
- * Priority: pnpm-lock.yaml > package-lock.json > fallback to detectFromUserAgent()
+ * Priority: explicit project metadata > lockfiles > workspace config > invocation/binaries
  */
 export function detectFromProject(projectDir?: string): PackageManager {
   const dir = projectDir || process.cwd();
 
+  const manifestPath = path.join(dir, "package.json");
+  if (fs.existsSync(manifestPath)) {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const manager = manifest.devEngines?.packageManager?.name || manifest.packageManager?.split("@")[0];
+    if (manager === "npm" || manager === "pnpm") return manager;
+  }
+
   if (fs.existsSync(path.join(dir, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
@@ -124,6 +128,7 @@ export function detectFromProject(projectDir?: string): PackageManager {
   }
 
   // No lockfile found — fall back to user agent detection
+  if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return "pnpm";
   return detectFromUserAgent();
 }
 
@@ -151,7 +156,7 @@ export function getWorkspaceConfig(pm: PackageManager, workspaces: string[]) {
       /** pnpm uses pnpm-workspace.yaml */
       type: "file" as const,
       filename: "pnpm-workspace.yaml",
-      content: `packages:\n${workspaces.map((w) => `  - ${w}`).join("\n")}\n`,
+      content: `packages:\n${workspaces.map((w) => `  - ${w}`).join("\n")}\nallowBuilds:\n  protobufjs: false\n  unrs-resolver: false\n`,
     };
   }
 
@@ -169,12 +174,29 @@ export function getWorkspaceConfig(pm: PackageManager, workspaces: string[]) {
 export function getCiSetupStep(pm: PackageManager): string {
   if (pm === "pnpm") {
     return `      - name: Setup pnpm
-        uses: pnpm/action-setup@v4`;
+        uses: pnpm/action-setup@v4
+        with:
+          version: 11`;
   }
   // npm: no extra setup needed (comes with Node.js)
   return "";
 }
 
+export function getCiInstallCommand(ciPm: PackageManager, projectPm: PackageManager = ciPm): string {
+  void projectPm; // Reserved for package-manager-specific CI bridging.
+  if (ciPm === "pnpm") {
+    return getCommands(ciPm).ci;
+  }
+  return getCommands(ciPm).ci;
+}
+
+export function getSwaAppBuildCommand(ciPm: PackageManager, projectPm: PackageManager = ciPm): string {
+  if (ciPm === "pnpm") {
+    return "pnpm install --frozen-lockfile && pnpm run build";
+  }
+  return `${getCiInstallCommand(ciPm, projectPm)} && npm run build`;
+}
+
 /**
  * CI/CD setup steps for Azure Pipelines
  */
@@ -182,7 +204,7 @@ export function getAzurePipelinesSetup(pm: PackageManager): string {
   if (pm === "pnpm") {
     return `  - script: |
       corepack enable
-      corepack prepare pnpm@latest --activate
+      corepack prepare pnpm@11 --activate
     displayName: 'Setup pnpm'`;
   }
   // npm: no extra step needed
@@ -196,7 +218,7 @@ export function getBuildScript(pm: PackageManager): string {
   const copyStandaloneAssets = `node -e "const fs=require('fs');fs.mkdirSync('.next/standalone/.next',{recursive:true});if(fs.existsSync('.next/static'))fs.cpSync('.next/static','.next/standalone/.next/static',{recursive:true});if(fs.existsSync('public'))fs.cpSync('public','.next/standalone/public',{recursive:true});"`;
 
   if (pm === "pnpm") {
-    return `pnpm run --filter shared build && next build --webpack && ${copyStandaloneAssets}`;
+    return `pnpm --filter shared run build && next build --webpack && ${copyStandaloneAssets}`;
   }
   return `npm run --workspace=shared build && next build --webpack && ${copyStandaloneAssets}`;
 }

package/src/utils/python-uv.ts

@@ -0,0 +1,96 @@
+import * as path from "path";
+
+export const SWALLOWKIT_PYTHON_VERSION = "3.11";
+
+export interface ProjectLocalUvPaths {
+  stateDir: string;
+  cacheDir: string;
+  pythonInstallDir: string;
+  toolDir: string;
+  toolBinDir: string;
+  localUvInstallDir: string;
+  localUvExecutable: string;
+}
+
+export function getPythonProjectRoot(functionsDir: string): string {
+  return path.dirname(functionsDir);
+}
+
+export function getProjectLocalUvPaths(projectRoot: string): ProjectLocalUvPaths {
+  const stateDir = path.join(projectRoot, ".uv");
+  const localUvInstallDir = path.join(stateDir, "bin");
+
+  return {
+    stateDir,
+    cacheDir: path.join(stateDir, "cache"),
+    pythonInstallDir: path.join(stateDir, "python"),
+    toolDir: path.join(stateDir, "tools"),
+    toolBinDir: path.join(stateDir, "tools", "bin"),
+    localUvInstallDir,
+    localUvExecutable: process.platform === "win32"
+      ? path.join(localUvInstallDir, "uv.exe")
+      : path.join(localUvInstallDir, "uv"),
+  };
+}
+
+export function buildProjectLocalUvEnv(
+  baseEnv: NodeJS.ProcessEnv,
+  projectRoot: string
+): NodeJS.ProcessEnv {
+  const uvPaths = getProjectLocalUvPaths(projectRoot);
+  const env: NodeJS.ProcessEnv = {
+    ...baseEnv,
+    UV_CACHE_DIR: uvPaths.cacheDir,
+    UV_PYTHON_INSTALL_DIR: uvPaths.pythonInstallDir,
+    UV_TOOL_DIR: uvPaths.toolDir,
+    UV_TOOL_BIN_DIR: uvPaths.toolBinDir,
+    UV_PYTHON_PREFERENCE: "only-managed",
+  };
+
+  if (process.platform === "win32") {
+    env.UV_PYTHON_NO_REGISTRY = "true";
+  }
+
+  return env;
+}
+
+export function buildProjectLocalUvInstallerEnv(
+  baseEnv: NodeJS.ProcessEnv,
+  projectRoot: string
+): NodeJS.ProcessEnv {
+  const uvPaths = getProjectLocalUvPaths(projectRoot);
+
+  return {
+    ...buildProjectLocalUvEnv(baseEnv, projectRoot),
+    UV_UNMANAGED_INSTALL: uvPaths.localUvInstallDir,
+    UV_NO_MODIFY_PATH: "1",
+  };
+}
+
+export function getProjectLocalUvInstallerCommand(): { command: string; args: string[] } {
+  if (process.platform === "win32") {
+    return {
+      command: "powershell",
+      args: [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        "$ProgressPreference = 'SilentlyContinue'; irm https://astral.sh/uv/install.ps1 | iex",
+      ],
+    };
+  }
+
+  return {
+    command: "sh",
+    args: ["-c", "curl -LsSf https://astral.sh/uv/install.sh | sh"],
+  };
+}
+
+export function buildUvVenvArgs(venvDir: string, pythonVersion = SWALLOWKIT_PYTHON_VERSION): string[] {
+  return ["venv", venvDir, "--python", pythonVersion];
+}
+
+export function buildUvPipInstallArgs(pythonExecutable: string, requirementsPath: string): string[] {
+  return ["pip", "install", "--python", pythonExecutable, "-r", requirementsPath];
+}

package/src/version.ts

@@ -0,0 +1,13 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export function getSwallowKitVersion(): string {
+  const packageJsonPath = path.resolve(__dirname, "..", "package.json");
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")) as { version?: string };
+    return packageJson.version || "0.0.0";
+  } catch {
+    return process.env.npm_package_version || "0.0.0";
+  }
+}