@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-ZCTSUQRR.js

@@ -0,0 +1,874 @@
+import {
+  CI_PLATFORM_FILES
+} from "./chunk-F6C3GFKV.js";
+import {
+  fileExists,
+  listDirectory,
+  readJson
+} from "./chunk-77V75A7O.js";
+
+// src/scanner/scan.ts
+import path7 from "path";
+
+// src/scanner/detect-git.ts
+import { execFile } from "child_process";
+import path from "path";
+import { promisify } from "util";
+
+// src/scanner/paths.ts
+var REPOSITORY_PROFILE_REL = ".cursor/agent-kit.config.json";
+
+// src/scanner/detect-git.ts
+var exec = promisify(execFile);
+function remoteHostname(remoteUrl) {
+  const scpMatch = remoteUrl.match(/^[^@]+@([^:]+):/);
+  if (scpMatch?.[1]) return scpMatch[1].toLowerCase();
+  try {
+    return new URL(remoteUrl).hostname.toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function sanitizeRemoteUrl(remoteUrl) {
+  try {
+    const parsed = new URL(remoteUrl);
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString();
+  } catch {
+    return remoteUrl;
+  }
+}
+async function detectProvider(rootDir, remoteUrl) {
+  const configuration = await readJson(
+    path.join(rootDir, REPOSITORY_PROFILE_REL)
+  );
+  const configuredProvider = configuration?.git?.provider;
+  if (configuredProvider) {
+    const configuredKind = configuration.git?.providerKind ?? (configuredProvider === "github" ? "github" : configuredProvider === "gitlab" ? remoteUrl && remoteHostname(remoteUrl) === "gitlab.com" ? "gitlab-saas" : "gitlab-self-hosted" : configuredProvider === "other" ? "custom" : "known-other");
+    return {
+      provider: configuredProvider,
+      providerKind: configuredKind,
+      confidence: "high",
+      evidence: [{ source: "configuration", value: `${REPOSITORY_PROFILE_REL}#git.provider` }]
+    };
+  }
+  if (!remoteUrl) {
+    return { providerKind: "unknown", confidence: "low", evidence: [] };
+  }
+  const hostname = remoteHostname(remoteUrl);
+  const remoteEvidence = [{ source: "git", value: `remote:${remoteUrl}` }];
+  if (hostname === "github.com") {
+    return {
+      provider: "github",
+      providerKind: "github",
+      confidence: "high",
+      evidence: remoteEvidence
+    };
+  }
+  if (hostname === "gitlab.com") {
+    return {
+      provider: "gitlab",
+      providerKind: "gitlab-saas",
+      confidence: "high",
+      evidence: remoteEvidence
+    };
+  }
+  if (hostname === "bitbucket.org") {
+    return {
+      provider: "bitbucket",
+      providerKind: "known-other",
+      confidence: "high",
+      evidence: remoteEvidence
+    };
+  }
+  if (hostname === "dev.azure.com" || hostname?.endsWith(".visualstudio.com")) {
+    return {
+      provider: "azure-devops",
+      providerKind: "known-other",
+      confidence: "high",
+      evidence: remoteEvidence
+    };
+  }
+  if (hostname === "codeberg.org") {
+    return {
+      provider: "gitea",
+      providerKind: "known-other",
+      confidence: "high",
+      evidence: remoteEvidence
+    };
+  }
+  if (await fileExists(path.join(rootDir, ".gitlab-ci.yml"))) {
+    return {
+      provider: "gitlab",
+      providerKind: "gitlab-self-hosted",
+      confidence: "medium",
+      evidence: [...remoteEvidence, { source: "file", value: ".gitlab-ci.yml" }]
+    };
+  }
+  return {
+    provider: "other",
+    providerKind: hostname ? "custom" : "unknown",
+    confidence: "low",
+    evidence: remoteEvidence
+  };
+}
+function inferWorkflow(currentBranch, hasLocalStaging, hasRemoteStaging) {
+  if (hasLocalStaging || hasRemoteStaging) return "homolog-prod";
+  if (!currentBranch) return "unknown";
+  if (currentBranch === "main" || currentBranch === "master") return "feature-pr";
+  if (currentBranch.includes("develop") || currentBranch.includes("release")) return "gitflow";
+  if (currentBranch.includes("staging") || currentBranch.includes("homolog")) return "homolog-prod";
+  return "feature-pr";
+}
+var GIT_MAX_BUFFER = 64 * 1024 * 1024;
+async function runGit(args, rootDir) {
+  try {
+    const { stdout } = await exec("git", args, { cwd: rootDir, maxBuffer: GIT_MAX_BUFFER });
+    return stdout.trim();
+  } catch {
+    return void 0;
+  }
+}
+async function listTrackedFiles(rootDir) {
+  return (await runGit(["ls-files"], rootDir))?.split("\n").filter(Boolean);
+}
+async function detectGitDirty(rootDir) {
+  return Boolean(await runGit(["status", "--porcelain"], rootDir));
+}
+async function detectGit(rootDir) {
+  const isGit = await runGit(["rev-parse", "--is-inside-work-tree"], rootDir) === "true";
+  if (!isGit) {
+    return {
+      providerKind: "unknown",
+      providerConfidence: "low",
+      providerEvidence: [],
+      remotes: [],
+      mode: "none",
+      workflow: "unknown",
+      isDirty: false,
+      hasLocalStaging: false,
+      hasRemoteStaging: false
+    };
+  }
+  const remoteNames = (await runGit(["remote"], rootDir))?.split("\n").filter(Boolean) ?? [];
+  const remotes = (await Promise.all(
+    remoteNames.map(async (name) => {
+      const url = await runGit(["remote", "get-url", name], rootDir);
+      return url ? { name, url: sanitizeRemoteUrl(url) } : void 0;
+    })
+  )).filter((remote) => remote !== void 0);
+  const primary = remotes.find((remote) => remote.name === "origin") ?? remotes[0];
+  const remoteUrl = primary?.url;
+  const [currentBranch, remoteHead, localBranchOutput, remoteBranchOutput, status, provider] = await Promise.all([
+    runGit(["branch", "--show-current"], rootDir),
+    primary ? runGit(["symbolic-ref", "--short", `refs/remotes/${primary.name}/HEAD`], rootDir) : Promise.resolve(void 0),
+    runGit(["for-each-ref", "--format=%(refname:short)", "refs/heads"], rootDir),
+    runGit(["for-each-ref", "--format=%(refname:short)", "refs/remotes"], rootDir),
+    runGit(["status", "--porcelain"], rootDir),
+    detectProvider(rootDir, remoteUrl)
+  ]);
+  const localBranches = localBranchOutput?.split("\n").filter(Boolean);
+  const remoteBranches = remoteBranchOutput?.split("\n").filter(Boolean);
+  const defaultBranch = remoteHead?.split("/").slice(1).join("/") || (localBranches?.includes("main") ? "main" : localBranches?.includes("master") ? "master" : void 0);
+  const hasLocalStaging = localBranches?.includes("staging") ?? false;
+  const hasRemoteStaging = remoteBranches?.some((branch) => remoteNames.some((r) => branch === `${r}/staging`)) ?? false;
+  return {
+    provider: provider.provider,
+    providerKind: provider.providerKind,
+    providerConfidence: provider.confidence,
+    providerEvidence: provider.evidence,
+    remoteUrl,
+    remoteName: primary?.name,
+    remotes,
+    mode: remotes.length > 0 ? "remote-hosted" : "local-only",
+    currentBranch,
+    defaultBranch,
+    isDirty: Boolean(status),
+    hasLocalStaging,
+    hasRemoteStaging,
+    workflow: inferWorkflow(currentBranch, hasLocalStaging, hasRemoteStaging)
+  };
+}
+
+// src/scanner/detect-ide.ts
+import path2 from "path";
+async function detectIde(rootDir) {
+  const hasCursor = await fileExists(path2.join(rootDir, ".cursor"));
+  const hasVSCode = await fileExists(path2.join(rootDir, ".vscode"));
+  const hasWindsurf = await fileExists(path2.join(rootDir, ".windsurfrules"));
+  if (hasCursor) return { ide: "cursor", plan: "cursor-pro" };
+  if (hasVSCode) return { ide: "vscode", plan: "vscode-pro" };
+  if (hasWindsurf) return { ide: "windsurf", plan: "windsurf" };
+  return { ide: "unknown", plan: "default" };
+}
+
+// src/scanner/detect-infra.ts
+import { readFile, readdir } from "fs/promises";
+import path3 from "path";
+function extractRunCommands(yaml) {
+  const lines = yaml.split(/\r?\n/);
+  const commands = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const match = /^(\s*)(?:-\s+)?run:\s*(.*)$/.exec(line);
+    if (!match) continue;
+    const [, indent = "", inline = ""] = match;
+    const trimmedInline = inline.trim();
+    if (trimmedInline && !/^[|>][+-]?$/.test(trimmedInline)) {
+      commands.push(trimmedInline.replace(/^['"]|['"]$/g, ""));
+      continue;
+    }
+    const blockIndent = indent.length;
+    for (let j = i + 1; j < lines.length; j++) {
+      const blockLine = lines[j] ?? "";
+      if (!blockLine.trim()) continue;
+      const lineIndent = blockLine.length - blockLine.trimStart().length;
+      if (lineIndent <= blockIndent) break;
+      commands.push(blockLine.trim());
+    }
+  }
+  return Array.from(new Set(commands));
+}
+async function detectCiRunCommands(rootDir) {
+  const workflowsDir = path3.join(rootDir, ".github", "workflows");
+  if (!await fileExists(workflowsDir)) return [];
+  let entries;
+  try {
+    entries = await readdir(workflowsDir);
+  } catch {
+    return [];
+  }
+  const workflowFiles = entries.filter((name) => /\.ya?ml$/.test(name));
+  const perFile = await Promise.all(
+    workflowFiles.map(async (name) => {
+      try {
+        return extractRunCommands(await readFile(path3.join(workflowsDir, name), "utf8"));
+      } catch {
+        return [];
+      }
+    })
+  );
+  return Array.from(new Set(perFile.flat()));
+}
+async function detectInfra(rootDir) {
+  const docker = await fileExists(path3.join(rootDir, "Dockerfile")) || await fileExists(path3.join(rootDir, "docker-compose.yml")) || await fileExists(path3.join(rootDir, "docker-compose.yaml"));
+  const kubernetes = await fileExists(path3.join(rootDir, "k8s")) || await fileExists(path3.join(rootDir, "kubernetes"));
+  let ci = "none";
+  const ciFiles = [];
+  for (const [platform, filePath] of Object.entries(CI_PLATFORM_FILES)) {
+    if (await fileExists(path3.join(rootDir, filePath))) {
+      if (ci === "none") ci = platform;
+      ciFiles.push(filePath);
+    }
+  }
+  const infrastructureCandidates = [
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "k8s",
+    "kubernetes",
+    "terraform",
+    "infra"
+  ];
+  const deploymentCandidates = [
+    "vercel.json",
+    "netlify.toml",
+    "fly.toml",
+    "render.yaml",
+    "Procfile",
+    "deploy",
+    "scripts/deploy.sh"
+  ];
+  const infrastructureFiles = (await Promise.all(
+    infrastructureCandidates.map(
+      async (file) => await fileExists(path3.join(rootDir, file)) ? file : void 0
+    )
+  )).filter((file) => file !== void 0);
+  const deploymentFiles = (await Promise.all(
+    deploymentCandidates.map(
+      async (file) => await fileExists(path3.join(rootDir, file)) ? file : void 0
+    )
+  )).filter((file) => file !== void 0);
+  const ciRunCommands = ci === "github-actions" ? await detectCiRunCommands(rootDir) : [];
+  return { docker, kubernetes, ci, ciFiles, infrastructureFiles, deploymentFiles, ciRunCommands };
+}
+
+// src/scanner/detect-repository.ts
+import { readFile as readFile2 } from "fs/promises";
+import path4 from "path";
+var CONTEXT_PATHS = [
+  ["README.md", "README"],
+  ["README", "README"],
+  ["AGENTS.md", "agent guidance"],
+  ["CLAUDE.md", "agent guidance"],
+  [".cursor/rules", "Cursor rules"],
+  ["docs/architecture.md", "architecture"],
+  ["docs/adr", "architecture decisions"],
+  ["docs/runbooks", "runbooks"],
+  ["runbooks", "runbooks"],
+  ["prompts", "prompts"],
+  ["schemas", "schemas"],
+  ["sql", "SQL"],
+  ["knowledge", "knowledge base"]
+];
+async function existingEvidence(rootDir, candidates) {
+  const evidence = await Promise.all(
+    candidates.map(
+      async ([relativePath, label]) => await fileExists(path4.join(rootDir, relativePath)) ? { source: "file", value: `${relativePath}:${label}` } : void 0
+    )
+  );
+  return evidence.flatMap((item) => item ? [item] : []);
+}
+async function detectContext(rootDir) {
+  const sources = await existingEvidence(rootDir, CONTEXT_PATHS);
+  const paths = sources.map((item) => item.value.split(":")[0]);
+  return {
+    sources,
+    hasReadme: paths.some((item) => item === "README" || item === "README.md"),
+    hasArchitecture: sources.some((item) => item.value.includes("architecture")),
+    hasRunbooks: sources.some((item) => item.value.includes("runbooks")),
+    hasAgentGuidance: sources.some(
+      (item) => item.value.includes("agent guidance") || item.value.includes("Cursor rules")
+    )
+  };
+}
+var REPOSITORY_PURPOSE_VALUES = [
+  "application",
+  "library",
+  "monorepo",
+  "documentation",
+  "knowledge",
+  "operations",
+  "automation",
+  "mixed",
+  "unknown"
+];
+function isRepositoryPurpose(value) {
+  return typeof value === "string" && REPOSITORY_PURPOSE_VALUES.includes(value);
+}
+async function readConfirmedPurpose(rootDir) {
+  const configuration = await readJson(
+    path4.join(rootDir, REPOSITORY_PROFILE_REL)
+  );
+  const configuredPurpose = configuration?.purpose;
+  if (!configuredPurpose || !isRepositoryPurpose(configuredPurpose.value) || configuredPurpose.value === "unknown") {
+    return void 0;
+  }
+  const categories = Array.isArray(configuredPurpose.categories) ? configuredPurpose.categories.filter(isRepositoryPurpose) : [];
+  const evidence = Array.isArray(configuredPurpose.evidence) ? configuredPurpose.evidence : [];
+  return {
+    value: configuredPurpose.value,
+    categories: categories.length > 0 ? categories : [configuredPurpose.value],
+    confidence: "high",
+    evidence: evidence.length > 0 ? evidence : [{ source: "configuration", value: `${REPOSITORY_PROFILE_REL}#purpose.value` }]
+  };
+}
+async function detectPurpose(rootDir, stack) {
+  const confirmed = await readConfirmedPurpose(rootDir);
+  if (confirmed) return confirmed;
+  const entries = await listDirectory(rootDir);
+  const lowerEntries = entries.map((entry) => entry.toLowerCase());
+  const packageJson = await readJson(path4.join(rootDir, "package.json"));
+  const categories = [];
+  const evidence = [];
+  const add = (category, value2) => {
+    if (!categories.includes(category)) categories.push(category);
+    evidence.push({ source: "file", value: value2 });
+  };
+  if (stack.workspaces) add("monorepo", "workspace configuration");
+  else if (stack.language === "node" && packageJson?.private !== true && (packageJson?.exports !== void 0 || packageJson?.main || packageJson?.types)) {
+    add("library", "package export configuration");
+  } else if (stack.hasProjectFiles) add("application", "application package marker");
+  if (lowerEntries.some((entry) => ["docs", "documentation", "mkdocs.yml"].includes(entry))) {
+    add("documentation", "documentation structure");
+  }
+  if (lowerEntries.some(
+    (entry) => ["knowledge", "content", "wiki", "playbooks", "handbook"].includes(entry)
+  )) {
+    add("knowledge", "knowledge structure");
+  }
+  if (lowerEntries.some(
+    (entry) => ["runbooks", "infra", "terraform", "ansible", "k8s", "kubernetes"].includes(entry)
+  )) {
+    add("operations", "operations structure");
+  }
+  if (lowerEntries.some(
+    (entry) => ["n8n", "workflows", "automations", "prompts", "sql", "schemas"].includes(entry)
+  ) || lowerEntries.some((entry) => entry.endsWith(".sql"))) {
+    add("automation", "automation or data artifact");
+  }
+  const meaningfulCategories = categories.filter((category) => category !== "unknown");
+  const value = meaningfulCategories.length === 0 ? "unknown" : meaningfulCategories.length === 1 ? meaningfulCategories[0] ?? "unknown" : "mixed";
+  return {
+    value,
+    categories: meaningfulCategories.length > 0 ? meaningfulCategories : ["unknown"],
+    confidence: evidence.length > 0 ? "high" : "low",
+    evidence
+  };
+}
+async function detectAgentKit(rootDir) {
+  const manifestRelativePath = ".cursor/agent-kit.json";
+  const manifestPath = path4.join(rootDir, manifestRelativePath);
+  const installed = await fileExists(manifestPath);
+  const manifest = installed ? await readJson(manifestPath) : null;
+  return {
+    installed,
+    manifestPath: installed ? manifestRelativePath : void 0,
+    version: manifest?.version,
+    hasPlans: await fileExists(path4.join(rootDir, ".cursor/plans")),
+    hasHandoff: await fileExists(path4.join(rootDir, ".cursor/HANDOFF.md")),
+    hasMemory: await fileExists(path4.join(rootDir, ".cursor/memory"))
+  };
+}
+var REQUIRED_SECRET_PATTERNS = [
+  ".env",
+  ".env.*",
+  "*.key",
+  "*.pem",
+  "*.p12",
+  "*.pfx",
+  "*credentials*.json",
+  "*service-account*.json"
+];
+var KIT_OWNED_IGNORE_PATTERNS = [
+  ".cursor/HANDOFF.md",
+  ".cursor/dogfood/",
+  ".cursor/context/readiness.json",
+  ".cursor/context/flight-log.json",
+  ".cursor/context/mission-timing.json"
+];
+function globToRegExp(glob) {
+  const body = glob.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*");
+  return new RegExp(`^${body}$`, "i");
+}
+var SECRET_FILE_MATCHERS = REQUIRED_SECRET_PATTERNS.map(globToRegExp);
+var ENV_TEMPLATE_RE = /^\.env(?:\..+)?\.(?:example|sample|template|dist)$/i;
+function isTrackedSecretFile(file) {
+  const base = file.slice(file.lastIndexOf("/") + 1);
+  if (ENV_TEMPLATE_RE.test(base)) return false;
+  return SECRET_FILE_MATCHERS.some((matcher) => matcher.test(base));
+}
+async function detectSafety(rootDir, trackedFiles) {
+  const gitignorePath = path4.join(rootDir, ".gitignore");
+  const hasGitignore = await fileExists(gitignorePath);
+  const gitignore = hasGitignore ? await readFile2(gitignorePath, "utf8") : "";
+  const lines = gitignore.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  const ignoredSecretPatterns = REQUIRED_SECRET_PATTERNS.filter(
+    (pattern) => lines.includes(pattern)
+  );
+  const trackedSensitiveFiles = (trackedFiles ?? []).filter(isTrackedSecretFile);
+  const hookPaths = [".husky", ".git/hooks/pre-commit", "git-hooks/pre-commit"];
+  const hasHooks = (await Promise.all(hookPaths.map((item) => fileExists(path4.join(rootDir, item))))).some(Boolean);
+  const guardCandidates = [
+    ".husky/pre-commit",
+    ".husky/pre-push",
+    "git-hooks/pre-commit",
+    "git-hooks/pre-push"
+  ];
+  const guardContents = await Promise.all(
+    guardCandidates.map(
+      async (item) => await fileExists(path4.join(rootDir, item)) ? readFile2(path4.join(rootDir, item), "utf8") : ""
+    )
+  );
+  return {
+    hasGitignore,
+    ignoredSecretPatterns,
+    missingSecretPatterns: REQUIRED_SECRET_PATTERNS.filter(
+      (pattern) => !ignoredSecretPatterns.includes(pattern)
+    ),
+    trackedSensitiveFiles,
+    ...trackedFiles === void 0 ? { trackedFilesUnknown: true } : {},
+    hasHooks,
+    hasMainBranchGuard: guardContents.some(
+      (content) => content.includes("main") || content.includes("master")
+    )
+  };
+}
+
+// src/scanner/detect-services.ts
+import { readFile as readFile3 } from "fs/promises";
+import path5 from "path";
+async function detectProjectManagement(rootDir) {
+  const tools = [];
+  const mcpConfigPaths = [
+    path5.join(rootDir, ".cursor", "mcp.json"),
+    path5.join(rootDir, "mcp.json")
+  ];
+  for (const configPath of mcpConfigPaths) {
+    if (!await fileExists(configPath)) continue;
+    try {
+      const raw = await readFile3(configPath, "utf8");
+      const lower = raw.toLowerCase();
+      if (lower.includes("clickup")) tools.push("clickup");
+      if (lower.includes("jira") || lower.includes("atlassian")) tools.push("jira");
+      if (lower.includes("linear")) tools.push("linear");
+      if (lower.includes("asana")) tools.push("asana");
+      if (lower.includes("youtrack")) tools.push("youtrack");
+      if (lower.includes("shortcut")) tools.push("shortcut");
+    } catch {
+    }
+  }
+  if (await fileExists(path5.join(rootDir, ".github", "ISSUE_TEMPLATE"))) {
+    tools.push("github-issues");
+  }
+  if (await fileExists(path5.join(rootDir, ".github", "projects"))) {
+    tools.push("github-projects");
+  }
+  return [...new Set(tools)];
+}
+async function detectServices(rootDir) {
+  const hasPrisma = await fileExists(path5.join(rootDir, "prisma/schema.prisma"));
+  const hasSequelize = await fileExists(path5.join(rootDir, "sequelize"));
+  const hasDrizzle = await fileExists(path5.join(rootDir, "drizzle.config.ts"));
+  const hasKnex = await fileExists(path5.join(rootDir, "knexfile.ts"));
+  const hasTypeorm = await fileExists(path5.join(rootDir, "ormconfig.json"));
+  const database = hasPrisma || hasSequelize || hasDrizzle || hasKnex || hasTypeorm ? "postgresql" : void 0;
+  const orm = hasPrisma ? "prisma" : hasDrizzle ? "drizzle" : hasSequelize ? "sequelize" : hasKnex ? "knex" : hasTypeorm ? "typeorm" : void 0;
+  const projectManagement = await detectProjectManagement(rootDir);
+  return {
+    database,
+    orm,
+    projectManagement: projectManagement.length > 0 ? projectManagement : void 0
+  };
+}
+
+// src/scanner/detect-stack.ts
+import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
+import path6 from "path";
+var PROJECT_MARKERS = [
+  "package.json",
+  "requirements.txt",
+  "pyproject.toml",
+  "go.mod",
+  "Gemfile",
+  "pom.xml",
+  "build.gradle",
+  "composer.json",
+  "Cargo.toml",
+  "pnpm-workspace.yaml",
+  "pubspec.yaml"
+];
+var SUBDIR_SCAN_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "build", ".dart_tool"]);
+async function scanSubdirectoryMarkers(rootDir) {
+  let entries;
+  try {
+    entries = await readdir2(rootDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const dirs = entries.filter((entry) => entry.isDirectory() && !SUBDIR_SCAN_SKIP.has(entry.name)).map((entry) => entry.name);
+  const candidates = dirs.flatMap((dir) => PROJECT_MARKERS.map((marker) => ({ dir, marker })));
+  const found = await Promise.all(
+    candidates.map(async (candidate) => {
+      const exists = await fileExists(path6.join(rootDir, candidate.dir, candidate.marker));
+      return exists ? candidate : null;
+    })
+  );
+  return found.filter((hit) => hit !== null);
+}
+function isFlutterPubspec(content) {
+  return /^\s*flutter:\s*$/m.test(content) || /sdk:\s*flutter\b/.test(content);
+}
+var DART_VALIDATION_COMMANDS = [
+  "dart analyze --fatal-infos",
+  "dart format --output=none --set-exit-if-changed ."
+];
+async function detectDartFlavor(pubspecDir) {
+  let content = "";
+  try {
+    content = await readFile4(path6.join(pubspecDir, "pubspec.yaml"), "utf8");
+  } catch {
+  }
+  return { isFlutter: isFlutterPubspec(content) };
+}
+async function detectStackFromSubdirHits(rootDir, hits) {
+  const packageManagerEvidence = hits.map((hit) => ({
+    source: "file",
+    value: `${hit.dir}/${hit.marker}`
+  }));
+  const dartHits = hits.filter((hit) => hit.marker === "pubspec.yaml");
+  if (dartHits.length > 0) {
+    const flavors = await Promise.all(
+      dartHits.map((hit) => detectDartFlavor(path6.join(rootDir, hit.dir)))
+    );
+    const testCommands = Array.from(
+      new Set(flavors.map((flavor) => flavor.isFlutter ? "flutter test" : "dart test"))
+    );
+    return {
+      language: "dart",
+      framework: flavors.some((flavor) => flavor.isFlutter) ? "flutter" : "dart",
+      workspaces: true,
+      testCommands,
+      validationCommands: DART_VALIDATION_COMMANDS,
+      hasProjectFiles: true,
+      packageManagerEvidence
+    };
+  }
+  const nodeHit = hits.find((hit) => hit.marker === "package.json");
+  if (nodeHit) {
+    const subRoot = path6.join(rootDir, nodeHit.dir);
+    const packageJson = await readJson(path6.join(subRoot, "package.json")) ?? {};
+    const scripts = packageJson.scripts ?? {};
+    const packageManager = await detectPackageManager(subRoot, packageJson);
+    const commands = commandsForScripts(scripts, packageManager.packageManager);
+    return {
+      language: "node",
+      framework: "node",
+      packageManager: packageManager.packageManager,
+      packageManagerEvidence: [...packageManagerEvidence, ...packageManager.evidence],
+      scripts,
+      workspaces: true,
+      ...commands,
+      hasProjectFiles: true
+    };
+  }
+  const languageByMarker = [
+    { marker: "pyproject.toml", language: "python", testCommands: [], validationCommands: [] },
+    { marker: "requirements.txt", language: "python", testCommands: [], validationCommands: [] },
+    { marker: "go.mod", language: "go", testCommands: ["go test ./..."], validationCommands: [] },
+    {
+      marker: "Cargo.toml",
+      language: "rust",
+      testCommands: ["cargo test"],
+      validationCommands: ["cargo check"]
+    },
+    { marker: "composer.json", language: "php", testCommands: [], validationCommands: [] }
+  ];
+  for (const candidate of languageByMarker) {
+    if (hits.some((hit) => hit.marker === candidate.marker)) {
+      return {
+        language: candidate.language,
+        framework: candidate.language,
+        workspaces: true,
+        testCommands: candidate.testCommands,
+        validationCommands: candidate.validationCommands,
+        hasProjectFiles: true,
+        packageManagerEvidence
+      };
+    }
+  }
+  return {
+    language: "unknown",
+    workspaces: true,
+    testCommands: [],
+    validationCommands: [],
+    hasProjectFiles: true,
+    packageManagerEvidence
+  };
+}
+var KNOWN_PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+function isDetectionEvidenceArray(value) {
+  return Array.isArray(value) && value.every(
+    (item) => item && typeof item === "object" && typeof item.value === "string" && typeof item.source === "string"
+  );
+}
+async function readConfirmedStack(rootDir) {
+  const configuration = await readJson(
+    path6.join(rootDir, REPOSITORY_PROFILE_REL)
+  );
+  const configured = configuration?.stack;
+  const language = configured?.language;
+  if (!configured || typeof language !== "string" || !language || language === "unknown") {
+    return void 0;
+  }
+  const testCommands = Array.isArray(configured.testCommands) ? configured.testCommands.filter((item) => typeof item === "string") : [];
+  const validationCommands = Array.isArray(configured.validationCommands) ? configured.validationCommands.filter((item) => typeof item === "string") : [];
+  if (testCommands.length === 0 && validationCommands.length === 0) return void 0;
+  const packageManager = typeof configured.packageManager === "string" && KNOWN_PACKAGE_MANAGERS.includes(configured.packageManager) ? configured.packageManager : void 0;
+  const scripts = configured.scripts && typeof configured.scripts === "object" && !Array.isArray(configured.scripts) ? configured.scripts : void 0;
+  const packageManagerEvidence = isDetectionEvidenceArray(
+    configured.packageManagerEvidence
+  ) ? configured.packageManagerEvidence : [{ source: "configuration", value: `${REPOSITORY_PROFILE_REL}#stack.language` }];
+  return {
+    language,
+    framework: typeof configured.framework === "string" ? configured.framework : void 0,
+    packageManager,
+    scripts,
+    workspaces: configured.workspaces === true,
+    testCommands,
+    validationCommands,
+    hasProjectFiles: true,
+    packageManagerEvidence
+  };
+}
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["package-lock.json", "npm"]
+];
+async function detectPackageManager(rootDir, packageJson) {
+  const configured = packageJson.packageManager?.split("@")[0];
+  if (configured && ["npm", "pnpm", "yarn", "bun"].includes(configured)) {
+    return {
+      packageManager: configured,
+      evidence: [{ source: "configuration", value: `package.json#packageManager=${configured}` }]
+    };
+  }
+  for (const [lockfile, packageManager] of LOCKFILES) {
+    if (await fileExists(path6.join(rootDir, lockfile))) {
+      return {
+        packageManager,
+        evidence: [{ source: "file", value: lockfile }]
+      };
+    }
+  }
+  return { evidence: [] };
+}
+function commandsForScripts(scripts, packageManager) {
+  const runner = packageManager ?? "npm";
+  const command = (name) => runner === "npm" ? `npm run ${name}` : `${runner} ${name}`;
+  const testCommands = Object.keys(scripts).filter((name) => name === "test" || name.startsWith("test:")).map(command);
+  const validationCommands = ["lint", "typecheck", "check", "build"].filter((name) => scripts[name]).map(command);
+  return { testCommands, validationCommands };
+}
+async function detectStack(rootDir) {
+  const confirmed = await readConfirmedStack(rootDir);
+  if (confirmed) return confirmed;
+  const hasAnyProjectMarker = (await Promise.all(PROJECT_MARKERS.map((item) => fileExists(path6.join(rootDir, item))))).some(Boolean);
+  if (!hasAnyProjectMarker) {
+    const subdirHits = await scanSubdirectoryMarkers(rootDir);
+    if (subdirHits.length > 0) {
+      return detectStackFromSubdirHits(rootDir, subdirHits);
+    }
+  }
+  const hasPackageJson = await fileExists(path6.join(rootDir, "package.json"));
+  if (hasPackageJson) {
+    const packageJson = await readJson(path6.join(rootDir, "package.json")) ?? {};
+    const scripts = packageJson.scripts ?? {};
+    const packageManager = await detectPackageManager(rootDir, packageJson);
+    const commands = commandsForScripts(scripts, packageManager.packageManager);
+    const hasNextConfig = await fileExists(path6.join(rootDir, "next.config.js")) || await fileExists(path6.join(rootDir, "next.config.mjs")) || await fileExists(path6.join(rootDir, "next.config.ts"));
+    const hasNestConfig = await fileExists(path6.join(rootDir, "nest-cli.json"));
+    return {
+      language: "node",
+      framework: hasNextConfig ? "nextjs" : hasNestConfig ? "nestjs" : "node",
+      packageManager: packageManager.packageManager,
+      packageManagerEvidence: packageManager.evidence,
+      scripts,
+      workspaces: packageJson.workspaces !== void 0 || await fileExists(path6.join(rootDir, "pnpm-workspace.yaml")),
+      ...commands,
+      hasProjectFiles: hasAnyProjectMarker
+    };
+  }
+  if (await fileExists(path6.join(rootDir, "pyproject.toml"))) {
+    return {
+      language: "python",
+      framework: "python",
+      workspaces: false,
+      testCommands: [],
+      validationCommands: [],
+      hasProjectFiles: hasAnyProjectMarker
+    };
+  }
+  if (await fileExists(path6.join(rootDir, "go.mod"))) {
+    return {
+      language: "go",
+      framework: "go",
+      workspaces: false,
+      testCommands: ["go test ./..."],
+      validationCommands: [],
+      hasProjectFiles: hasAnyProjectMarker
+    };
+  }
+  if (await fileExists(path6.join(rootDir, "Cargo.toml"))) {
+    return {
+      language: "rust",
+      framework: "rust",
+      workspaces: false,
+      testCommands: ["cargo test"],
+      validationCommands: ["cargo check"],
+      hasProjectFiles: hasAnyProjectMarker
+    };
+  }
+  if (await fileExists(path6.join(rootDir, "composer.json"))) {
+    return {
+      language: "php",
+      framework: "php",
+      workspaces: false,
+      testCommands: [],
+      validationCommands: [],
+      hasProjectFiles: hasAnyProjectMarker
+    };
+  }
+  if (await fileExists(path6.join(rootDir, "pubspec.yaml"))) {
+    const { isFlutter } = await detectDartFlavor(rootDir);
+    return {
+      language: "dart",
+      framework: isFlutter ? "flutter" : "dart",
+      workspaces: false,
+      testCommands: [isFlutter ? "flutter test" : "dart test"],
+      validationCommands: DART_VALIDATION_COMMANDS,
+      hasProjectFiles: hasAnyProjectMarker
+    };
+  }
+  return {
+    language: "unknown",
+    workspaces: false,
+    testCommands: [],
+    validationCommands: [],
+    hasProjectFiles: hasAnyProjectMarker
+  };
+}
+
+// src/scanner/scan.ts
+var GREENFIELD_SAFE_FILES = /* @__PURE__ */ new Set([
+  ".git",
+  ".gitignore",
+  "LICENSE",
+  "README.md",
+  ".cursor",
+  ".vscode"
+]);
+function isGreenfieldByEntries(entries) {
+  const meaningful = entries.filter((entry) => !GREENFIELD_SAFE_FILES.has(entry));
+  return meaningful.length === 0;
+}
+async function runScanner(rootDir) {
+  const normalizedRoot = path7.resolve(rootDir);
+  const entries = await listDirectory(normalizedRoot);
+  const stack = await detectStack(normalizedRoot);
+  const purpose = await detectPurpose(normalizedRoot, stack);
+  const [git, ide, infra, services, context, agentKit, trackedFiles] = await Promise.all([
+    detectGit(normalizedRoot),
+    detectIde(normalizedRoot),
+    detectInfra(normalizedRoot),
+    detectServices(normalizedRoot),
+    detectContext(normalizedRoot),
+    detectAgentKit(normalizedRoot),
+    listTrackedFiles(normalizedRoot)
+  ]);
+  const safety = await detectSafety(normalizedRoot, git.mode === "none" ? [] : trackedFiles);
+  const isGreenfield = isGreenfieldByEntries(entries) && purpose.value === "unknown";
+  return {
+    rootDir: normalizedRoot,
+    isGreenfield,
+    purpose,
+    stack,
+    git,
+    ide,
+    infra,
+    services,
+    context,
+    agentKit,
+    safety,
+    quality: {
+      testCommands: stack.testCommands,
+      validationCommands: stack.validationCommands,
+      ci: infra.ci,
+      hasTests: stack.testCommands.length > 0,
+      ciRunCommands: infra.ciRunCommands
+    }
+  };
+}
+
+export {
+  detectIde,
+  REPOSITORY_PROFILE_REL,
+  detectGitDirty,
+  REQUIRED_SECRET_PATTERNS,
+  KIT_OWNED_IGNORE_PATTERNS,
+  runScanner
+};