@ulpi/cli 0.1.0

package/dist/chunk-2CLNOKPA.js

@@ -0,0 +1,793 @@
+// ../../packages/stack-engine/dist/index.js
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { existsSync as existsSync2, readFileSync, statSync } from "fs";
+import { join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join5 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join6 } from "path";
+import { execFileSync } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
+function detectRuntime(projectDir) {
+  if (existsSync(join(projectDir, "package.json"))) {
+    return { id: "node", name: "Node.js", confidence: "high", signal: "package.json" };
+  }
+  if (existsSync(join(projectDir, "requirements.txt")) || existsSync(join(projectDir, "pyproject.toml")) || existsSync(join(projectDir, "setup.py"))) {
+    const signal = existsSync(join(projectDir, "requirements.txt")) ? "requirements.txt" : existsSync(join(projectDir, "pyproject.toml")) ? "pyproject.toml" : "setup.py";
+    return { id: "python", name: "Python", confidence: "high", signal };
+  }
+  if (existsSync(join(projectDir, "go.mod"))) {
+    return { id: "go", name: "Go", confidence: "high", signal: "go.mod" };
+  }
+  if (existsSync(join(projectDir, "Cargo.toml"))) {
+    return { id: "rust", name: "Rust", confidence: "high", signal: "Cargo.toml" };
+  }
+  if (existsSync(join(projectDir, "composer.json"))) {
+    return { id: "php", name: "PHP", confidence: "high", signal: "composer.json" };
+  }
+  if (existsSync(join(projectDir, "Gemfile"))) {
+    return { id: "ruby", name: "Ruby", confidence: "high", signal: "Gemfile" };
+  }
+  if (existsSync(join(projectDir, "pubspec.yaml"))) {
+    return { id: "dart", name: "Dart", confidence: "high", signal: "pubspec.yaml" };
+  }
+  if (existsSync(join(projectDir, "pom.xml")) || existsSync(join(projectDir, "build.gradle")) || existsSync(join(projectDir, "build.gradle.kts"))) {
+    const signal = existsSync(join(projectDir, "pom.xml")) ? "pom.xml" : existsSync(join(projectDir, "build.gradle")) ? "build.gradle" : "build.gradle.kts";
+    return { id: "java", name: "Java", confidence: "high", signal };
+  }
+  try {
+    const entries = readdirSync(projectDir);
+    const csharpFile = entries.find((e) => e.endsWith(".csproj") || e.endsWith(".sln"));
+    if (csharpFile) {
+      return { id: "csharp", name: "C#", confidence: "high", signal: csharpFile };
+    }
+  } catch {
+  }
+  if (existsSync(join(projectDir, "mix.exs"))) {
+    return { id: "elixir", name: "Elixir", confidence: "high", signal: "mix.exs" };
+  }
+  return null;
+}
+function detectLanguage(projectDir) {
+  if (existsSync(join(projectDir, "tsconfig.json")) && existsSync(join(projectDir, "package.json"))) {
+    return { id: "typescript", name: "TypeScript", confidence: "high", signal: "tsconfig.json" };
+  }
+  if (existsSync(join(projectDir, "package.json"))) {
+    return { id: "javascript", name: "JavaScript", confidence: "high", signal: "package.json" };
+  }
+  if (existsSync(join(projectDir, "requirements.txt")) || existsSync(join(projectDir, "pyproject.toml")) || existsSync(join(projectDir, "setup.py"))) {
+    return { id: "python", name: "Python", confidence: "high", signal: "python project files" };
+  }
+  if (existsSync(join(projectDir, "go.mod"))) {
+    return { id: "go", name: "Go", confidence: "high", signal: "go.mod" };
+  }
+  if (existsSync(join(projectDir, "Cargo.toml"))) {
+    return { id: "rust", name: "Rust", confidence: "high", signal: "Cargo.toml" };
+  }
+  if (existsSync(join(projectDir, "composer.json"))) {
+    return { id: "php", name: "PHP", confidence: "high", signal: "composer.json" };
+  }
+  if (existsSync(join(projectDir, "Gemfile"))) {
+    return { id: "ruby", name: "Ruby", confidence: "high", signal: "Gemfile" };
+  }
+  if (existsSync(join(projectDir, "pubspec.yaml"))) {
+    return { id: "dart", name: "Dart", confidence: "high", signal: "pubspec.yaml" };
+  }
+  if (existsSync(join(projectDir, "mix.exs"))) {
+    return { id: "elixir", name: "Elixir", confidence: "high", signal: "mix.exs" };
+  }
+  return null;
+}
+var MAX_CONFIG_SIZE = 5e6;
+function isReadable(filePath) {
+  try {
+    if (!existsSync2(filePath)) return false;
+    const stat = statSync(filePath);
+    if (stat.size > MAX_CONFIG_SIZE) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readJsonFile(filePath) {
+  try {
+    if (!isReadable(filePath)) return null;
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function readTextFile(filePath) {
+  try {
+    if (!isReadable(filePath)) return null;
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function getNodeDependencies(projectDir) {
+  const pkg = readJsonFile(join2(projectDir, "package.json"));
+  if (!pkg) return /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Set();
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    const section = pkg[field];
+    if (section && typeof section === "object") {
+      for (const name of Object.keys(section)) {
+        deps.add(name);
+      }
+    }
+  }
+  return deps;
+}
+function getPythonDependencies(projectDir) {
+  const deps = /* @__PURE__ */ new Set();
+  const requirements = readTextFile(join2(projectDir, "requirements.txt"));
+  if (requirements) {
+    for (const line of requirements.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("-")) {
+        const match = trimmed.match(/^([a-zA-Z0-9_-]+)/);
+        if (match) deps.add(match[1].toLowerCase());
+      }
+    }
+  }
+  return deps;
+}
+function getComposerDependencies(projectDir) {
+  const composer = readJsonFile(join2(projectDir, "composer.json"));
+  if (!composer) return /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Set();
+  for (const field of ["require", "require-dev"]) {
+    const section = composer[field];
+    if (section && typeof section === "object") {
+      for (const name of Object.keys(section)) {
+        deps.add(name);
+      }
+    }
+  }
+  return deps;
+}
+function getGoDependencies(projectDir) {
+  const gomod = readTextFile(join2(projectDir, "go.mod"));
+  if (!gomod) return /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Set();
+  const requireBlockRegex = /require\s*\(([\s\S]*?)\)/g;
+  let match;
+  while ((match = requireBlockRegex.exec(gomod)) !== null) {
+    const block = match[1];
+    for (const line of block.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("//")) {
+        const parts = trimmed.split(/\s+/);
+        if (parts[0]) deps.add(parts[0]);
+      }
+    }
+  }
+  const singleRegex = /^require\s+(\S+)\s+/gm;
+  while ((match = singleRegex.exec(gomod)) !== null) {
+    if (match[1]) deps.add(match[1]);
+  }
+  return deps;
+}
+function getCargoDependencies(projectDir) {
+  const cargo = readTextFile(join2(projectDir, "Cargo.toml"));
+  if (!cargo) return /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Set();
+  const sectionRegex = /\[((?:dev-|build-)?dependencies)\]([\s\S]*?)(?=\n\[|$)/g;
+  let match;
+  while ((match = sectionRegex.exec(cargo)) !== null) {
+    const block = match[2];
+    for (const line of block.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        const keyMatch = trimmed.match(/^([a-zA-Z0-9_-]+)\s*=/);
+        if (keyMatch && keyMatch[1]) deps.add(keyMatch[1]);
+      }
+    }
+  }
+  return deps;
+}
+function getGemDependencies(projectDir) {
+  const gemfile = readTextFile(join2(projectDir, "Gemfile"));
+  if (!gemfile) return /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Set();
+  const gemRegex = /^\s*gem\s+['"]([^'"]+)['"]/gm;
+  let match;
+  while ((match = gemRegex.exec(gemfile)) !== null) {
+    if (match[1]) deps.add(match[1]);
+  }
+  return deps;
+}
+function getMixDependencies(projectDir) {
+  const mixExs = readTextFile(join2(projectDir, "mix.exs"));
+  if (!mixExs) return /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Set();
+  const depRegex = /\{:([a-z_]+)/g;
+  let match;
+  while ((match = depRegex.exec(mixExs)) !== null) {
+    if (match[1]) deps.add(match[1]);
+  }
+  return deps;
+}
+var NODE_FRAMEWORKS = [
+  { pkg: "next", id: "nextjs", name: "Next.js" },
+  { pkg: "express", id: "express", name: "Express" },
+  { pkg: "@nestjs/core", id: "nestjs", name: "NestJS" },
+  { pkg: "react-native", id: "react-native", name: "React Native" },
+  { pkg: "astro", id: "astro", name: "Astro" },
+  { pkg: "svelte", id: "svelte", name: "Svelte" }
+];
+var PYTHON_FRAMEWORKS = [
+  { pkg: "django", id: "django", name: "Django" },
+  { pkg: "flask", id: "flask", name: "Flask" },
+  { pkg: "fastapi", id: "fastapi", name: "FastAPI" }
+];
+var PHP_FRAMEWORKS = [
+  { pkg: "laravel/framework", id: "laravel", name: "Laravel" },
+  { pkg: "symfony/framework-bundle", id: "symfony", name: "Symfony" }
+];
+var GO_FRAMEWORKS = [
+  { pkg: "github.com/gin-gonic/gin", id: "gin", name: "Gin" },
+  { pkg: "github.com/labstack/echo", id: "echo", name: "Echo" }
+];
+var RUST_FRAMEWORKS = [
+  { pkg: "actix-web", id: "actix", name: "Actix" },
+  { pkg: "axum", id: "axum", name: "Axum" }
+];
+function findInSet(deps, mappings, signalSource) {
+  for (const mapping of mappings) {
+    if (deps.has(mapping.pkg)) {
+      return {
+        id: mapping.id,
+        name: mapping.name,
+        confidence: "high",
+        signal: `${mapping.pkg} in ${signalSource}`
+      };
+    }
+  }
+  return null;
+}
+function findInGoDeps(deps, mappings) {
+  for (const mapping of mappings) {
+    for (const dep of deps) {
+      if (dep === mapping.pkg || dep.startsWith(mapping.pkg)) {
+        return {
+          id: mapping.id,
+          name: mapping.name,
+          confidence: "high",
+          signal: `${mapping.pkg} in go.mod`
+        };
+      }
+    }
+  }
+  return null;
+}
+function detectFramework(projectDir) {
+  const nodeDeps = getNodeDependencies(projectDir);
+  if (nodeDeps.size > 0) {
+    const result = findInSet(nodeDeps, NODE_FRAMEWORKS, "package.json");
+    if (result) return result;
+  }
+  const pyDeps = getPythonDependencies(projectDir);
+  if (pyDeps.size > 0) {
+    const result = findInSet(pyDeps, PYTHON_FRAMEWORKS, "requirements.txt");
+    if (result) return result;
+  }
+  const composerDeps = getComposerDependencies(projectDir);
+  if (composerDeps.size > 0) {
+    const result = findInSet(composerDeps, PHP_FRAMEWORKS, "composer.json");
+    if (result) return result;
+  }
+  const goDeps = getGoDependencies(projectDir);
+  if (goDeps.size > 0) {
+    const result = findInGoDeps(goDeps, GO_FRAMEWORKS);
+    if (result) return result;
+  }
+  const cargoDeps = getCargoDependencies(projectDir);
+  if (cargoDeps.size > 0) {
+    const result = findInSet(cargoDeps, RUST_FRAMEWORKS, "Cargo.toml");
+    if (result) return result;
+  }
+  const gemDeps = getGemDependencies(projectDir);
+  if (gemDeps.has("rails")) {
+    return { id: "rails", name: "Rails", confidence: "high", signal: "rails in Gemfile" };
+  }
+  const mixDeps = getMixDependencies(projectDir);
+  if (mixDeps.has("phoenix")) {
+    return { id: "phoenix", name: "Phoenix", confidence: "high", signal: "phoenix in mix.exs" };
+  }
+  return null;
+}
+var LOCK_FILES = [
+  { file: "pnpm-lock.yaml", id: "pnpm", name: "pnpm" },
+  { file: "yarn.lock", id: "yarn", name: "yarn" },
+  { file: "package-lock.json", id: "npm", name: "npm" },
+  { file: "bun.lockb", id: "bun", name: "bun" },
+  { file: "bun.lock", id: "bun", name: "bun" },
+  { file: "poetry.lock", id: "poetry", name: "poetry" },
+  { file: "uv.lock", id: "uv", name: "uv" },
+  { file: "Pipfile.lock", id: "pipenv", name: "pipenv" },
+  { file: "go.sum", id: "gomod", name: "go mod" },
+  { file: "Cargo.lock", id: "cargo", name: "cargo" },
+  { file: "composer.lock", id: "composer", name: "composer" },
+  { file: "Gemfile.lock", id: "bundler", name: "bundler" }
+];
+function detectPackageManager(projectDir) {
+  for (const mapping of LOCK_FILES) {
+    if (existsSync3(join3(projectDir, mapping.file))) {
+      return {
+        id: mapping.id,
+        name: mapping.name,
+        confidence: "high",
+        signal: mapping.file
+      };
+    }
+  }
+  return null;
+}
+function detectFormatter(projectDir) {
+  const prettierConfigs = [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.yml",
+    ".prettierrc.yaml",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.mjs",
+    ".prettierrc.toml",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs"
+  ];
+  for (const config of prettierConfigs) {
+    if (existsSync4(join4(projectDir, config))) {
+      return { id: "prettier", name: "Prettier", confidence: "high", signal: config };
+    }
+  }
+  const pkg = readJsonFile(join4(projectDir, "package.json"));
+  if (pkg && "prettier" in pkg) {
+    return {
+      id: "prettier",
+      name: "Prettier",
+      confidence: "high",
+      signal: "prettier key in package.json"
+    };
+  }
+  if (existsSync4(join4(projectDir, "biome.json"))) {
+    return { id: "biome", name: "Biome", confidence: "high", signal: "biome.json" };
+  }
+  if (existsSync4(join4(projectDir, "biome.jsonc"))) {
+    return { id: "biome", name: "Biome", confidence: "high", signal: "biome.jsonc" };
+  }
+  const pyproject = readTextFile(join4(projectDir, "pyproject.toml"));
+  if (pyproject) {
+    if (pyproject.includes("[tool.black]")) {
+      return {
+        id: "black",
+        name: "Black",
+        confidence: "high",
+        signal: "[tool.black] in pyproject.toml"
+      };
+    }
+    if (pyproject.includes("[tool.ruff.format]")) {
+      return {
+        id: "ruff-format",
+        name: "Ruff format",
+        confidence: "high",
+        signal: "[tool.ruff.format] in pyproject.toml"
+      };
+    }
+  }
+  if (existsSync4(join4(projectDir, "rustfmt.toml")) || existsSync4(join4(projectDir, ".rustfmt.toml"))) {
+    const signal = existsSync4(join4(projectDir, "rustfmt.toml")) ? "rustfmt.toml" : ".rustfmt.toml";
+    return { id: "rustfmt", name: "rustfmt", confidence: "high", signal };
+  }
+  if (existsSync4(join4(projectDir, ".editorconfig")) && existsSync4(join4(projectDir, "go.mod"))) {
+    return {
+      id: "gofmt",
+      name: "gofmt",
+      confidence: "medium",
+      signal: ".editorconfig with Go project"
+    };
+  }
+  return null;
+}
+function hasFileMatching(projectDir, prefix) {
+  try {
+    const entries = readdirSync2(projectDir);
+    const match = entries.find((e) => e.startsWith(prefix));
+    return match ?? null;
+  } catch {
+    return null;
+  }
+}
+function detectLinter(projectDir) {
+  const eslintFlatConfigs = [
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs",
+    "eslint.config.ts",
+    "eslint.config.mts",
+    "eslint.config.cts"
+  ];
+  for (const config of eslintFlatConfigs) {
+    if (existsSync5(join5(projectDir, config))) {
+      return { id: "eslint", name: "ESLint", confidence: "high", signal: config };
+    }
+  }
+  const eslintLegacy = hasFileMatching(projectDir, ".eslintrc");
+  if (eslintLegacy) {
+    return { id: "eslint", name: "ESLint", confidence: "high", signal: eslintLegacy };
+  }
+  const pkg = readJsonFile(join5(projectDir, "package.json"));
+  if (pkg && "eslintConfig" in pkg) {
+    return {
+      id: "eslint",
+      name: "ESLint",
+      confidence: "high",
+      signal: "eslintConfig in package.json"
+    };
+  }
+  if (existsSync5(join5(projectDir, "biome.json")) || existsSync5(join5(projectDir, "biome.jsonc"))) {
+    const signal = existsSync5(join5(projectDir, "biome.json")) ? "biome.json" : "biome.jsonc";
+    return { id: "biome-lint", name: "Biome lint", confidence: "high", signal };
+  }
+  if (existsSync5(join5(projectDir, "tsconfig.json"))) {
+    return {
+      id: "typescript",
+      name: "TypeScript",
+      confidence: "high",
+      signal: "tsconfig.json"
+    };
+  }
+  const pyproject = readTextFile(join5(projectDir, "pyproject.toml"));
+  if (pyproject && pyproject.includes("[tool.ruff]")) {
+    return {
+      id: "ruff",
+      name: "Ruff",
+      confidence: "high",
+      signal: "[tool.ruff] in pyproject.toml"
+    };
+  }
+  if (existsSync5(join5(projectDir, ".flake8"))) {
+    return { id: "flake8", name: "Flake8", confidence: "medium", signal: ".flake8" };
+  }
+  const setupCfg = readTextFile(join5(projectDir, "setup.cfg"));
+  if (setupCfg && setupCfg.includes("[flake8]")) {
+    return {
+      id: "flake8",
+      name: "Flake8",
+      confidence: "medium",
+      signal: "[flake8] in setup.cfg"
+    };
+  }
+  if (existsSync5(join5(projectDir, ".golangci.yml")) || existsSync5(join5(projectDir, ".golangci.yaml"))) {
+    const signal = existsSync5(join5(projectDir, ".golangci.yml")) ? ".golangci.yml" : ".golangci.yaml";
+    return { id: "golangci-lint", name: "golangci-lint", confidence: "high", signal };
+  }
+  if (existsSync5(join5(projectDir, "Cargo.toml"))) {
+    return {
+      id: "clippy",
+      name: "Clippy",
+      confidence: "medium",
+      signal: "Rust project (Cargo.toml)"
+    };
+  }
+  const phpstanFile = hasFileMatching(projectDir, "phpstan.neon");
+  if (phpstanFile) {
+    return { id: "phpstan", name: "PHPStan", confidence: "high", signal: phpstanFile };
+  }
+  return null;
+}
+function hasFileMatching2(projectDir, prefix) {
+  try {
+    const entries = readdirSync3(projectDir);
+    const match = entries.find((e) => e.startsWith(prefix));
+    return match ?? null;
+  } catch {
+    return null;
+  }
+}
+function hasTestGoFiles(projectDir) {
+  try {
+    const entries = readdirSync3(projectDir);
+    return entries.some((e) => e.endsWith("_test.go"));
+  } catch {
+    return false;
+  }
+}
+function detectTestRunner(projectDir) {
+  const vitestConfigs = [
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mts",
+    "vitest.config.mjs"
+  ];
+  for (const config of vitestConfigs) {
+    if (existsSync6(join6(projectDir, config))) {
+      return { id: "vitest", name: "Vitest", confidence: "high", signal: config };
+    }
+  }
+  const nodeDeps = getNodeDependencies(projectDir);
+  if (nodeDeps.has("vitest")) {
+    return {
+      id: "vitest",
+      name: "Vitest",
+      confidence: "high",
+      signal: "vitest in package.json"
+    };
+  }
+  const jestConfigs = [
+    "jest.config.ts",
+    "jest.config.js",
+    "jest.config.mjs",
+    "jest.config.cjs"
+  ];
+  for (const config of jestConfigs) {
+    if (existsSync6(join6(projectDir, config))) {
+      return { id: "jest", name: "Jest", confidence: "high", signal: config };
+    }
+  }
+  const pkg = readJsonFile(join6(projectDir, "package.json"));
+  if (pkg && "jest" in pkg) {
+    return { id: "jest", name: "Jest", confidence: "high", signal: "jest key in package.json" };
+  }
+  if (nodeDeps.has("jest")) {
+    return { id: "jest", name: "Jest", confidence: "high", signal: "jest in package.json" };
+  }
+  if (existsSync6(join6(projectDir, "pytest.ini"))) {
+    return { id: "pytest", name: "pytest", confidence: "high", signal: "pytest.ini" };
+  }
+  if (existsSync6(join6(projectDir, "pyproject.toml"))) {
+    const pyproject = readTextFile(join6(projectDir, "pyproject.toml"));
+    if (pyproject && pyproject.includes("[tool.pytest")) {
+      return {
+        id: "pytest",
+        name: "pytest",
+        confidence: "high",
+        signal: "[tool.pytest] in pyproject.toml"
+      };
+    }
+  }
+  if (existsSync6(join6(projectDir, "go.mod")) && hasTestGoFiles(projectDir)) {
+    return {
+      id: "gotest",
+      name: "go test",
+      confidence: "medium",
+      signal: "*_test.go files in project"
+    };
+  }
+  if (existsSync6(join6(projectDir, "Cargo.toml"))) {
+    return {
+      id: "cargo-test",
+      name: "cargo test",
+      confidence: "medium",
+      signal: "Rust project (Cargo.toml)"
+    };
+  }
+  const phpunitFile = hasFileMatching2(projectDir, "phpunit.xml");
+  if (phpunitFile) {
+    return { id: "phpunit", name: "PHPUnit", confidence: "high", signal: phpunitFile };
+  }
+  const composerDeps = getComposerDependencies(projectDir);
+  if (composerDeps.has("pestphp/pest")) {
+    return {
+      id: "pest",
+      name: "Pest",
+      confidence: "high",
+      signal: "pestphp/pest in composer.json"
+    };
+  }
+  return null;
+}
+function getGitBranches(projectDir) {
+  try {
+    const output = execFileSync("git", ["branch", "-a"], {
+      cwd: projectDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).toString();
+    return output.split("\n").map((b) => b.trim().replace(/^\*\s*/, "").replace(/^remotes\/origin\//, "")).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getRecentCommitMessages(projectDir, count = 20) {
+  try {
+    const output = execFileSync("git", ["log", "--oneline", `-${count}`, "--format=%s"], {
+      cwd: projectDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).toString();
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function detectGitWorkflow(projectDir) {
+  const branches = getGitBranches(projectDir);
+  if (existsSync7(join7(projectDir, "pnpm-workspace.yaml")) || existsSync7(join7(projectDir, "lerna.json")) || existsSync7(join7(projectDir, "nx.json"))) {
+    const signal = existsSync7(join7(projectDir, "pnpm-workspace.yaml")) ? "pnpm-workspace.yaml" : existsSync7(join7(projectDir, "lerna.json")) ? "lerna.json" : "nx.json";
+    return { id: "monorepo", name: "Monorepo", confidence: "high", signal };
+  }
+  if (existsSync7(join7(projectDir, ".gitmodules"))) {
+    return {
+      id: "git-submodules",
+      name: "Git Submodules",
+      confidence: "high",
+      signal: ".gitmodules"
+    };
+  }
+  if (branches.length === 0) {
+    return null;
+  }
+  const hasDevelop = branches.some((b) => b === "develop" || b === "development");
+  const hasFeatureBranches = branches.some((b) => b.startsWith("feature/"));
+  const hasReleaseBranches = branches.some((b) => b.startsWith("release/"));
+  const hasHotfixBranches = branches.some((b) => b.startsWith("hotfix/"));
+  if (hasDevelop && (hasFeatureBranches || hasReleaseBranches || hasHotfixBranches)) {
+    return {
+      id: "git-flow",
+      name: "Git Flow",
+      confidence: "high",
+      signal: "develop branch with feature/release/hotfix branches"
+    };
+  }
+  if (hasFeatureBranches && !hasDevelop) {
+    return {
+      id: "github-flow",
+      name: "GitHub Flow",
+      confidence: "medium",
+      signal: "feature/* branches without develop"
+    };
+  }
+  const messages = getRecentCommitMessages(projectDir);
+  if (messages.length > 0) {
+    const conventionalPattern = /^(feat|fix|chore|docs|style|refactor|perf|test|build|ci|revert)(\(.+\))?:/;
+    const conventionalCount = messages.filter((m) => conventionalPattern.test(m)).length;
+    if (conventionalCount >= messages.length * 0.5 && conventionalCount >= 3) {
+      return {
+        id: "conventional-commits",
+        name: "Conventional Commits",
+        confidence: "medium",
+        signal: `${conventionalCount}/${messages.length} commits match conventional pattern`
+      };
+    }
+  }
+  if (branches.length > 0) {
+    return { id: "simple", name: "Simple", confidence: "low", signal: "no clear workflow pattern" };
+  }
+  return null;
+}
+function detectOrm(projectDir) {
+  const nodeDeps = getNodeDependencies(projectDir);
+  if (existsSync8(join8(projectDir, "prisma", "schema.prisma"))) {
+    return {
+      id: "prisma",
+      name: "Prisma",
+      confidence: "high",
+      signal: "prisma/schema.prisma"
+    };
+  }
+  if (nodeDeps.has("prisma") || nodeDeps.has("@prisma/client")) {
+    return {
+      id: "prisma",
+      name: "Prisma",
+      confidence: "high",
+      signal: "prisma in package.json"
+    };
+  }
+  const drizzleConfigs = [
+    "drizzle.config.ts",
+    "drizzle.config.js",
+    "drizzle.config.mjs",
+    "drizzle.config.mts"
+  ];
+  for (const config of drizzleConfigs) {
+    if (existsSync8(join8(projectDir, config))) {
+      return { id: "drizzle", name: "Drizzle", confidence: "high", signal: config };
+    }
+  }
+  if (nodeDeps.has("drizzle-orm")) {
+    return {
+      id: "drizzle",
+      name: "Drizzle",
+      confidence: "high",
+      signal: "drizzle-orm in package.json"
+    };
+  }
+  if (nodeDeps.has("typeorm")) {
+    return {
+      id: "typeorm",
+      name: "TypeORM",
+      confidence: "high",
+      signal: "typeorm in package.json"
+    };
+  }
+  if (nodeDeps.has("sequelize")) {
+    return {
+      id: "sequelize",
+      name: "Sequelize",
+      confidence: "high",
+      signal: "sequelize in package.json"
+    };
+  }
+  const pyDeps = getPythonDependencies(projectDir);
+  if (pyDeps.has("django")) {
+    return {
+      id: "django-orm",
+      name: "Django ORM",
+      confidence: "high",
+      signal: "django in Python dependencies"
+    };
+  }
+  if (pyDeps.has("sqlalchemy")) {
+    return {
+      id: "sqlalchemy",
+      name: "SQLAlchemy",
+      confidence: "high",
+      signal: "sqlalchemy in requirements"
+    };
+  }
+  const gemDeps = getGemDependencies(projectDir);
+  if (gemDeps.has("activerecord") || gemDeps.has("rails")) {
+    const signal = gemDeps.has("activerecord") ? "activerecord in Gemfile" : "rails in Gemfile";
+    return { id: "activerecord", name: "ActiveRecord", confidence: "high", signal };
+  }
+  return null;
+}
+function safeDetect(name, fn) {
+  try {
+    return fn();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[ulpi] Warning: ${name} detector failed: ${message}`);
+    return null;
+  }
+}
+function detectStack(projectDir) {
+  const runtime = safeDetect("runtime", () => detectRuntime(projectDir));
+  const language = safeDetect("language", () => detectLanguage(projectDir));
+  const framework = safeDetect("framework", () => detectFramework(projectDir));
+  const packageManager = safeDetect("packageManager", () => detectPackageManager(projectDir));
+  const formatter = safeDetect("formatter", () => detectFormatter(projectDir));
+  const linter = safeDetect("linter", () => detectLinter(projectDir));
+  const testRunner = safeDetect("testRunner", () => detectTestRunner(projectDir));
+  const gitWorkflow = safeDetect("gitWorkflow", () => detectGitWorkflow(projectDir));
+  const orm = safeDetect("orm", () => detectOrm(projectDir));
+  const features = [];
+  if (language?.id === "typescript") features.push("typescript");
+  if (orm) features.push("database");
+  if (testRunner) features.push("testing");
+  if (formatter) features.push("formatting");
+  if (linter) features.push("linting");
+  if (gitWorkflow?.id === "monorepo") features.push("monorepo");
+  if (gitWorkflow?.id === "conventional-commits") features.push("conventional-commits");
+  return {
+    runtime,
+    language,
+    framework,
+    packageManager,
+    formatter,
+    linter,
+    testRunner,
+    orm,
+    gitWorkflow,
+    deployment: null,
+    // Reserved for future deployment detector
+    features
+  };
+}
+
+export {
+  detectStack
+};