@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-X75S7HFS.js

@@ -0,0 +1,374 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  clioStateDir
+} from "./chunk-BNAZZHFG.js";
+import {
+  AI_AGENT_NAME
+} from "./chunk-6EJMN2Y3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/commit-attribution.ts
+init_esm_shims();
+var CLIO_COMMIT_IDENTITY = "Clio Coder <clio-coder@iowarp.ai>";
+var CLIO_COMMIT_TRAILERS = {
+  assisted: `Assisted-by: ${CLIO_COMMIT_IDENTITY}`,
+  tested: `Tested-by: ${CLIO_COMMIT_IDENTITY}`,
+  reviewed: `Reviewed-by: ${CLIO_COMMIT_IDENTITY}`,
+  coAuthored: `Co-authored-by: ${CLIO_COMMIT_IDENTITY}`
+};
+var TRAILER_LINE = /^([A-Za-z0-9][A-Za-z0-9-]*):[ \t]+(.+)$/u;
+var SHA256 = /^[0-9a-f]{64}$/u;
+function normalizedTrailer(line) {
+  const match = TRAILER_LINE.exec(line);
+  if (match === null) return null;
+  return `${match[1]?.toLowerCase()}:${match[2]?.trim().replace(/[ \t]+/gu, " ").toLowerCase()}`;
+}
+var KNOWN_CLIO_TRAILERS = new Set(
+  Object.values(CLIO_COMMIT_TRAILERS).map((line) => normalizedTrailer(line)).filter((line) => line !== null)
+);
+function isClioTrailer(key) {
+  return KNOWN_CLIO_TRAILERS.has(key) || key.startsWith("clio-evidence:receipt-v15/sha256:");
+}
+function trailerBlockStart(lines) {
+  if (lines.length < 2) return null;
+  const separator = lines.lastIndexOf("");
+  const first = separator + 1;
+  if (separator < 0 || first >= lines.length) return null;
+  let sawTrailer = false;
+  for (const line of lines.slice(first)) {
+    if (TRAILER_LINE.test(line)) {
+      sawTrailer = true;
+      continue;
+    }
+    if (sawTrailer && /^[ \t]+/u.test(line)) continue;
+    return null;
+  }
+  return sawTrailer ? first : null;
+}
+function receiptTrailer(receipt) {
+  if (receipt?.version !== 15 || receipt.algorithm !== "sha256" || receipt.integrityValid !== true || receipt.directlyRelevant !== true || !SHA256.test(receipt.digest)) {
+    return null;
+  }
+  return `Clio-Evidence: receipt-v15/sha256:${receipt.digest}`;
+}
+function attributeCommitMessage(originalMessage, evidence, enabled = true) {
+  if (!enabled) return originalMessage;
+  const normalized = originalMessage.replace(/\r\n?/gu, "\n");
+  const lines = normalized.replace(/\n+$/u, "").split("\n");
+  const blockStart = trailerBlockStart(lines);
+  const seenClio = /* @__PURE__ */ new Set();
+  const retained = lines.filter((line, index) => {
+    if (blockStart === null || index < blockStart) return true;
+    const key = normalizedTrailer(line);
+    if (key === null || !isClioTrailer(key)) return true;
+    if (seenClio.has(key)) return false;
+    seenClio.add(key);
+    return true;
+  });
+  const desired = [];
+  if (evidence.materiallyAssisted === true || evidence.materiallyAuthored === true) {
+    desired.push(CLIO_COMMIT_TRAILERS.assisted);
+  }
+  if (evidence.validationSucceeded === true) desired.push(CLIO_COMMIT_TRAILERS.tested);
+  if (evidence.independentReviewPassed === true) desired.push(CLIO_COMMIT_TRAILERS.reviewed);
+  if (evidence.materiallyAuthored === true) desired.push(CLIO_COMMIT_TRAILERS.coAuthored);
+  const receipt = receiptTrailer(evidence.receipt);
+  if (receipt !== null) desired.push(receipt);
+  const existing = new Set(
+    (blockStart === null ? [] : retained.slice(blockStart)).map((line) => normalizedTrailer(line)).filter((line) => line !== null)
+  );
+  const additions = desired.filter((line) => !existing.has(normalizedTrailer(line) ?? ""));
+  if (additions.length === 0) return `${retained.join("\n")}
+`;
+  if (blockStart === null) {
+    while (retained.at(-1) === "") retained.pop();
+    retained.push("", ...additions);
+  } else {
+    retained.push(...additions);
+  }
+  return `${retained.join("\n")}
+`;
+}
+
+// src/core/git-commit-attribution.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+var CLIO_GIT_COMMITS_ENABLED_ENV = "CLIO_CODER_GIT_COMMITS_ENABLED";
+var ASSISTED_ENV = "CLIO_CODER_COMMIT_ASSISTED";
+var AUTHORED_ENV = "CLIO_CODER_COMMIT_AUTHORED";
+var CONFIG_BASE_COUNT_ENV = "CLIO_CODER_GIT_CONFIG_BASE_COUNT";
+var DEFAULT_HOOKS_EQUIVALENT_ENV = "CLIO_CODER_GIT_DEFAULT_HOOKS_EQUIVALENT";
+var MANAGED_HOOK_VERSION = 2;
+var DIAGNOSTIC_MAX_CHARS = 300;
+var COUNT = /^(?:0|[1-9][0-9]*)$/u;
+var reportedDiagnostics = /* @__PURE__ */ new Set();
+var PROBE_CACHE_TTL_MS = 1e4;
+var PROBE_CACHE_MAX_ENTRIES = 32;
+var probeCache = /* @__PURE__ */ new Map();
+var installedHooksDirectory = null;
+var PER_SPAWN_ENV_NAMES = [ASSISTED_ENV, AUTHORED_ENV, CONFIG_BASE_COUNT_ENV, DEFAULT_HOOKS_EQUIVALENT_ENV];
+function reportCommitAttributionDiagnostic(diagnostic) {
+  if (diagnostic === null || reportedDiagnostics.has(diagnostic)) return;
+  reportedDiagnostics.add(diagnostic);
+  process.stderr.write(`[clio:attribution] ${diagnostic}
+`);
+}
+function setGitCommitAttributionEnabled(enabled) {
+  process.env[CLIO_GIT_COMMITS_ENABLED_ENV] = enabled ? "1" : "0";
+}
+function gitCommitAttributionEnabled(source = process.env) {
+  return source[CLIO_GIT_COMMITS_ENABLED_ENV] !== "0";
+}
+function boundedDiagnostic(message) {
+  const folded = message.replace(/\s+/gu, " ").trim();
+  return folded.length <= DIAGNOSTIC_MAX_CHARS ? folded : `${folded.slice(0, DIAGNOSTIC_MAX_CHARS - 3)}...`;
+}
+function withoutManagedGitConfig(source) {
+  const env = { ...source };
+  const baseRaw = env[CONFIG_BASE_COUNT_ENV];
+  const currentRaw = env.GIT_CONFIG_COUNT;
+  if (baseRaw !== void 0 && COUNT.test(baseRaw) && currentRaw !== void 0 && COUNT.test(currentRaw)) {
+    const base = Number(baseRaw);
+    for (let index = base; index < Number(currentRaw); index += 1) {
+      Reflect.deleteProperty(env, `GIT_CONFIG_KEY_${index}`);
+      Reflect.deleteProperty(env, `GIT_CONFIG_VALUE_${index}`);
+    }
+    if (base === 0) Reflect.deleteProperty(env, "GIT_CONFIG_COUNT");
+    else env.GIT_CONFIG_COUNT = String(base);
+  }
+  for (const name of PER_SPAWN_ENV_NAMES) Reflect.deleteProperty(env, name);
+  return env;
+}
+function gitOutput(cwd, env, args) {
+  try {
+    return execFileSync("git", [...args], {
+      cwd,
+      env,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+var MANAGED_HOOK_NAMES = [
+  "applypatch-msg",
+  "pre-applypatch",
+  "post-applypatch",
+  "pre-commit",
+  "pre-merge-commit",
+  "prepare-commit-msg",
+  "commit-msg",
+  "post-commit",
+  "pre-rebase",
+  "post-checkout",
+  "post-merge",
+  "pre-push",
+  "pre-receive",
+  "update",
+  "proc-receive",
+  "post-receive",
+  "post-update",
+  "reference-transaction",
+  "push-to-checkout",
+  "pre-auto-gc",
+  "post-rewrite",
+  "sendemail-validate",
+  "post-index-change"
+];
+var MANAGED_HOOK_SCRIPT = `#!/bin/sh
+# Clio Coder managed Git hook v${MANAGED_HOOK_VERSION}. Selected only through
+# command-scope configuration in Clio child-process environments.
+
+hook_name=$(basename "$0")
+
+base_count=$${CONFIG_BASE_COUNT_ENV}
+case "$base_count" in
+  '' | *[!0-9]*)
+    printf '%s\\n' '[clio:attribution] invalid managed hook environment' >&2
+    exit 0
+    ;;
+  0) unset GIT_CONFIG_COUNT ;;
+  *)
+    GIT_CONFIG_COUNT=$base_count
+    export GIT_CONFIG_COUNT
+    ;;
+esac
+
+# A command may have moved into a different repository after Clio prepared the
+# environment. A repository with its own core.hooksPath gets its hook run and
+# is never attributed; composing an unknown setup is not attempted.
+if [ "$${DEFAULT_HOOKS_EQUIVALENT_ENV}" != '1' ] && git config --get core.hooksPath >/dev/null 2>&1; then
+  custom_hooks=$(git config --path --get core.hooksPath 2>/dev/null || true)
+  case "$custom_hooks" in
+    '') ;;
+    /*) custom_hook=$custom_hooks/$hook_name ;;
+    *) custom_hook=$PWD/$custom_hooks/$hook_name ;;
+  esac
+  if [ -n "$custom_hooks" ] && [ -x "$custom_hook" ]; then exec "$custom_hook" "$@"; fi
+  exit 0
+fi
+
+common_dir=$(git rev-parse --git-common-dir 2>/dev/null || true)
+case "$common_dir" in
+  '') default_hook= ;;
+  /*) default_hook=$common_dir/hooks/$hook_name ;;
+  *) default_hook=$PWD/$common_dir/hooks/$hook_name ;;
+esac
+
+if [ "$hook_name" != 'prepare-commit-msg' ]; then
+  if [ -n "$default_hook" ] && [ -x "$default_hook" ]; then exec "$default_hook" "$@"; fi
+  exit 0
+fi
+
+message_file=$1
+message_source=$2
+
+if [ -n "$default_hook" ] && [ -x "$default_hook" ]; then
+  "$default_hook" "$@" || exit $?
+fi
+
+# The repository's own hook semantics are settled. Everything below is
+# fail-open and applies only to Clio-spawned commits with attribution enabled.
+if [ "$AI_AGENT" != '${AI_AGENT_NAME}' ] || [ "$${CLIO_GIT_COMMITS_ENABLED_ENV}" != '1' ]; then exit 0; fi
+
+# Only a message supplied up front (-m, -F, or a merge) is attributed. --amend,
+# -c/-C, squash, and template sources reuse or lack a real message, and an
+# editor session starts from an all-comment template where added trailers
+# would turn an abandoned editor into a commit whose whole message is trailers.
+case "$message_source" in message|merge) ;; *) exit 0 ;; esac
+for marker in CHERRY_PICK_HEAD REVERT_HEAD rebase-apply rebase-merge sequencer; do
+  marker_path=$(git rev-parse --git-path "$marker" 2>/dev/null || true)
+  if [ -n "$marker_path" ] && [ -e "$marker_path" ]; then exit 0; fi
+done
+
+# Case-insensitive presence check on the whole message, so a human-written
+# variant of a Clio trailer is respected rather than duplicated.
+has_trailer() {
+  awk -v wanted="$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]')" '
+    { line=$0; gsub(/[ \\t]+/, " ", line); sub(/ $/, "", line); if (tolower(line) == wanted) found=1 }
+    END { exit found ? 0 : 1 }' "$message_file"
+}
+
+append_trailer() {
+  if has_trailer "$1"; then return 0; fi
+  git interpret-trailers --in-place --if-exists=addIfDifferent --trailer "$1" "$message_file" ||
+    printf '%s\\n' '[clio:attribution] git interpret-trailers failed; commit left as written' >&2
+}
+
+if [ "$${ASSISTED_ENV}" = '1' ] || [ "$${AUTHORED_ENV}" = '1' ]; then
+  append_trailer '${CLIO_COMMIT_TRAILERS.assisted}'
+fi
+if [ "$${AUTHORED_ENV}" = '1' ]; then append_trailer '${CLIO_COMMIT_TRAILERS.coAuthored}'; fi
+exit 0
+`;
+function installManagedHook(directory, name) {
+  const hook = join(directory, name);
+  try {
+    if (existsSync(hook) && readFileSync(hook, "utf8") === MANAGED_HOOK_SCRIPT) {
+      chmodSync(hook, 493);
+      return;
+    }
+  } catch {
+  }
+  const temporary = `${hook}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(temporary, MANAGED_HOOK_SCRIPT, { encoding: "utf8", mode: 493 });
+    renameSync(temporary, hook);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+function managedHooksDirectory() {
+  const directory = join(clioStateDir(), "git-hooks", `v${MANAGED_HOOK_VERSION}`);
+  if (installedHooksDirectory === directory && existsSync(join(directory, "prepare-commit-msg"))) return directory;
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  for (const name of MANAGED_HOOK_NAMES) installManagedHook(directory, name);
+  installedHooksDirectory = directory;
+  return directory;
+}
+function gitEnvironmentFingerprint(env) {
+  const parts = [];
+  for (const key of Object.keys(env)) {
+    if (key.startsWith("GIT_") || key === "HOME" || key === "XDG_CONFIG_HOME") parts.push(`${key}=${env[key] ?? ""}`);
+  }
+  return parts.sort().join("\0");
+}
+function probeRepositoryUncached(cwd, env) {
+  if (gitOutput(cwd, env, ["rev-parse", "--is-inside-work-tree"]) !== "true") return { kind: "outside" };
+  const customHooksPath = gitOutput(cwd, env, ["config", "--path", "--get", "core.hooksPath"]);
+  if (customHooksPath === null) return { kind: "default", declaredDefault: false };
+  const commonDirectory = gitOutput(cwd, env, ["rev-parse", "--git-common-dir"]);
+  const defaultHooksPath = commonDirectory === null ? null : resolve(cwd, commonDirectory, "hooks");
+  if (customHooksPath.length === 0 || resolve(cwd, customHooksPath) !== defaultHooksPath) {
+    return { kind: "custom", hooksPath: customHooksPath };
+  }
+  return { kind: "default", declaredDefault: true };
+}
+function probeRepository(cwd, env, now = Date.now()) {
+  const key = `${cwd}\0${gitEnvironmentFingerprint(env)}`;
+  const cached = probeCache.get(key);
+  if (cached !== void 0 && now - cached.at < PROBE_CACHE_TTL_MS && now >= cached.at) return cached.probe;
+  const probe = probeRepositoryUncached(cwd, env);
+  if (cached === void 0 && probeCache.size >= PROBE_CACHE_MAX_ENTRIES) {
+    const oldest = probeCache.keys().next().value;
+    if (oldest !== void 0) probeCache.delete(oldest);
+  }
+  probeCache.delete(key);
+  probeCache.set(key, { at: now, probe });
+  return probe;
+}
+function withManagedGitCommitAttributionEnvironment(source, options = {}) {
+  const env = withoutManagedGitConfig(source);
+  env.AI_AGENT = AI_AGENT_NAME;
+  const enabled = options.enabled ?? gitCommitAttributionEnabled(source);
+  env[CLIO_GIT_COMMITS_ENABLED_ENV] = enabled ? "1" : "0";
+  if (!enabled) return { env, diagnostic: null };
+  const evidence = options.evidence ?? { materiallyAssisted: true, materiallyAuthored: true };
+  env[ASSISTED_ENV] = evidence.materiallyAssisted === true ? "1" : "0";
+  env[AUTHORED_ENV] = evidence.materiallyAuthored === true ? "1" : "0";
+  const countRaw = env.GIT_CONFIG_COUNT;
+  const count = countRaw === void 0 ? 0 : COUNT.test(countRaw) ? Number(countRaw) : Number.NaN;
+  if (!Number.isSafeInteger(count) || count > 1024) {
+    return { env, diagnostic: boundedDiagnostic("GIT_CONFIG_COUNT is invalid; Clio commit attribution skipped") };
+  }
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const probe = probeRepository(cwd, env);
+  if (probe.kind === "outside") return { env, diagnostic: null };
+  if (probe.kind === "custom") {
+    return {
+      env,
+      diagnostic: boundedDiagnostic(`core.hooksPath is set to '${probe.hooksPath}'; Clio commit attribution skipped`)
+    };
+  }
+  if (probe.declaredDefault) env[DEFAULT_HOOKS_EQUIVALENT_ENV] = "1";
+  let hooksDirectory;
+  try {
+    hooksDirectory = managedHooksDirectory();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return {
+      env,
+      diagnostic: boundedDiagnostic(`managed hooks unavailable; Clio commit attribution skipped (${reason})`)
+    };
+  }
+  env[CONFIG_BASE_COUNT_ENV] = String(count);
+  env.GIT_CONFIG_COUNT = String(count + 1);
+  env[`GIT_CONFIG_KEY_${count}`] = "core.hooksPath";
+  env[`GIT_CONFIG_VALUE_${count}`] = hooksDirectory;
+  return { env, diagnostic: null };
+}
+
+export {
+  attributeCommitMessage,
+  reportCommitAttributionDiagnostic,
+  setGitCommitAttributionEnabled,
+  gitCommitAttributionEnabled,
+  withManagedGitCommitAttributionEnvironment
+};
+//# sourceMappingURL=chunk-X75S7HFS.js.map

package/dist/chunk-XN3L4EYL.js

@@ -0,0 +1,46 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  StringEnum
+} from "./chunk-FCSXB6T2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/codewiki/code-nav-surface.ts
+init_esm_shims();
+var CODE_NAV_DEFAULT_LIMIT = 50;
+var CODE_NAV_DEFAULT_ENTRY_LIMIT = 25;
+var CODE_NAV_MAX_LIMIT = 200;
+var codeNavToolSurface = {
+  name: ToolNames.CodeNav,
+  description: "Navigate the indexed codewiki: mode=symbol finds files by symbol, path finds files by glob/regex/substring, entries lists likely entry points, outline lists file symbols, deps lists imports, and dependents lists importers. mode=wiki without query lists generated Markdown wiki pages; with query it resolves a page id/title and returns its summary plus a path to open with read. For Clio's bundled product docs use context scope=docs.",
+  parameters: typebox_exports.Object({
+    mode: StringEnum(["symbol", "path", "entries", "outline", "deps", "dependents", "wiki"], {
+      description: "Lookup mode."
+    }),
+    query: typebox_exports.Optional(
+      typebox_exports.String({ description: "Symbol name, indexed path/pattern/substring, or wiki page id/title." })
+    ),
+    limit: typebox_exports.Optional(
+      typebox_exports.Number({
+        description: `Max results (default ${CODE_NAV_DEFAULT_LIMIT}, entries ${CODE_NAV_DEFAULT_ENTRY_LIMIT}, max ${CODE_NAV_MAX_LIMIT}).`
+      })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel"
+};
+
+export {
+  CODE_NAV_DEFAULT_LIMIT,
+  CODE_NAV_DEFAULT_ENTRY_LIMIT,
+  CODE_NAV_MAX_LIMIT,
+  codeNavToolSurface
+};
+//# sourceMappingURL=chunk-XN3L4EYL.js.map

package/dist/{chunk-RDLVBZEO.js → chunk-YCWGATWI.js}

@@ -1,11 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  printError,
+  printError
+} from "./chunk-ED4KHGC3.js";
+import {
   source_default
-} from "./chunk-K2ITRMHZ.js";
+} from "./chunk-5TSRNF4G.js";
 import {
   authStoragePath
-} from "./chunk-GB6QRBXN.js";
+} from "./chunk-4VP4KH3K.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -33,4 +35,4 @@ export {
   printPlaintextCredentialWarning,
   credentialWriteFailed
 };
-//# sourceMappingURL=chunk-RDLVBZEO.js.map
+//# sourceMappingURL=chunk-YCWGATWI.js.map

package/dist/chunk-YHZX5GEU.js

@@ -0,0 +1,193 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  enumerateWorkspaceFiles
+} from "./chunk-EKMEHE4H.js";
+import {
+  classifyCHeaderLanguage
+} from "./chunk-7CR24IG7.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/session/workspace/project-type.ts
+init_esm_shims();
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var SOURCE_LANGUAGES = [
+  "typescript",
+  "javascript",
+  "python",
+  "rust",
+  "go",
+  "c",
+  "c++",
+  "java",
+  "ruby",
+  "c#"
+];
+var EXTENSION_LANGUAGES = /* @__PURE__ */ new Map([
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".py", "python"],
+  [".pyw", "python"],
+  [".rs", "rust"],
+  [".go", "go"],
+  [".c", "c"],
+  [".h", "c"],
+  [".cc", "c++"],
+  [".cpp", "c++"],
+  [".cxx", "c++"],
+  [".hpp", "c++"],
+  [".hh", "c++"],
+  [".hxx", "c++"],
+  [".cu", "c++"],
+  [".cuh", "c++"],
+  [".java", "java"],
+  [".rb", "ruby"],
+  [".cs", "c#"]
+]);
+var MANIFEST_LANGUAGES = [
+  { name: "package.json", type: "typescript" },
+  { name: "pyproject.toml", type: "python" },
+  { name: "setup.py", type: "python" },
+  { name: "Cargo.toml", type: "rust" },
+  { name: "go.mod", type: "go" },
+  { name: "pom.xml", type: "java" },
+  { name: "CMakeLists.txt", type: "c++" },
+  { name: "compile_commands.json", type: "c++" },
+  { name: "Gemfile", type: "ruby" },
+  { name: "*.csproj", type: "c#" }
+];
+function emptyLanguageCounts() {
+  return {
+    typescript: 0,
+    javascript: 0,
+    python: 0,
+    rust: 0,
+    go: 0,
+    c: 0,
+    "c++": 0,
+    java: 0,
+    ruby: 0,
+    "c#": 0
+  };
+}
+function extensionOf(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function countManifest(name, manifestCounts) {
+  for (const marker of MANIFEST_LANGUAGES) {
+    if (marker.name.startsWith("*.")) {
+      const ext = marker.name.slice(1);
+      if (name.endsWith(ext)) {
+        manifestCounts[marker.type] = (manifestCounts[marker.type] ?? 0) + 1;
+      }
+    } else {
+      if (name !== marker.name) continue;
+      manifestCounts[marker.type] = (manifestCounts[marker.type] ?? 0) + 1;
+    }
+  }
+}
+function scanFiles(cwd, files, languageCounts, manifestCounts) {
+  for (const path of files) {
+    const name = path.split("/").pop() ?? path;
+    countManifest(name, manifestCounts);
+    if (name.endsWith(".d.ts")) continue;
+    const extension = extensionOf(name);
+    let language = EXTENSION_LANGUAGES.get(extension);
+    if (extension === ".h") {
+      try {
+        language = classifyCHeaderLanguage(readFileSync(join(cwd, path), "utf8"));
+      } catch {
+        language = "c";
+      }
+    }
+    if (language) languageCounts[language] += 1;
+  }
+}
+function looksLikeDotfiles(files) {
+  const dotDirs = /* @__PURE__ */ new Set();
+  for (const path of files) {
+    const [root, child] = path.split("/", 2);
+    if (child && root?.startsWith("dot-")) dotDirs.add(root);
+  }
+  return dotDirs.size >= 2;
+}
+function dominantFromCounts(counts) {
+  let best;
+  let bestCount = 0;
+  for (const language of SOURCE_LANGUAGES) {
+    const count = counts[language] ?? 0;
+    if (count > bestCount) {
+      best = language;
+      bestCount = count;
+    } else if (count === bestCount && count > 0) {
+      best = void 0;
+    }
+  }
+  return best;
+}
+function detectProjectProfile(cwd) {
+  const languageCounts = emptyLanguageCounts();
+  const manifestCounts = {};
+  const files = enumerateWorkspaceFiles(cwd);
+  scanFiles(cwd, files, languageCounts, manifestCounts);
+  const sourceFiles = SOURCE_LANGUAGES.reduce((sum, language) => sum + languageCounts[language], 0);
+  const dominantSource = dominantFromCounts(languageCounts);
+  const dominantCount = dominantSource ? languageCounts[dominantSource] : 0;
+  const polyglot = sourceFiles > 0 && dominantCount / sourceFiles <= 0.7;
+  if (sourceFiles > 0) {
+    return {
+      projectType: polyglot ? "polyglot" : dominantSource ?? "polyglot",
+      sourceFiles,
+      languageCounts,
+      manifestCounts,
+      ...dominantSource ? { dominantLanguage: dominantSource } : {},
+      polyglot
+    };
+  }
+  const manifestDominant = dominantFromCounts(manifestCounts);
+  if (manifestDominant) {
+    return {
+      projectType: manifestDominant,
+      sourceFiles,
+      languageCounts,
+      manifestCounts,
+      dominantLanguage: manifestDominant,
+      polyglot: false
+    };
+  }
+  const manifestTotal = SOURCE_LANGUAGES.reduce((sum, language) => sum + (manifestCounts[language] ?? 0), 0);
+  if (manifestTotal > 0) {
+    return {
+      projectType: "polyglot",
+      sourceFiles,
+      languageCounts,
+      manifestCounts,
+      polyglot: true
+    };
+  }
+  return {
+    projectType: looksLikeDotfiles(files) ? "dotfiles" : "unknown",
+    sourceFiles,
+    languageCounts,
+    manifestCounts,
+    polyglot: false
+  };
+}
+function detectProjectType(cwd) {
+  return detectProjectProfile(cwd).projectType;
+}
+
+export {
+  detectProjectProfile,
+  detectProjectType
+};
+//# sourceMappingURL=chunk-YHZX5GEU.js.map