@iowarp/clio-coder 0.3.0

package/dist/chunk-X3BR7HWV.js

@@ -0,0 +1,115 @@
+// src/domains/context/codewiki/digest.ts
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+function topTwoSegments(path) {
+  const parts = path.split("/").slice(0, -1);
+  if (parts.length === 0) return ".";
+  return parts.slice(0, 2).join("/");
+}
+function sourceFiles(codewiki) {
+  return codewiki.files.filter((file) => file.lang !== "config").sort((a, b) => a.path.localeCompare(b.path));
+}
+function countBy(items) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) counts.set(item, (counts.get(item) ?? 0) + 1);
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+}
+function entryPoints(codewiki, limit) {
+  const files = sourceFiles(codewiki);
+  const tagged = files.filter((file) => file.role === "entry");
+  if (tagged.length >= limit) return tagged.slice(0, limit);
+  const fileById = new Map(files.map((file) => [file.id, file]));
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    if ("toFileId" in edge) inDegree.set(edge.toFileId, (inDegree.get(edge.toFileId) ?? 0) + 1);
+  }
+  const taggedIds = new Set(tagged.map((file) => file.id));
+  const ranked = [...inDegree.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([id]) => fileById.get(id)).filter((file) => file !== void 0 && !taggedIds.has(file.id));
+  return [...tagged, ...ranked].slice(0, limit);
+}
+function keySymbols(codewiki, limit) {
+  const rank = /* @__PURE__ */ new Map([
+    ["class", 0],
+    ["trait", 1],
+    ["iface", 2],
+    ["type", 3],
+    ["func", 4],
+    ["method", 5],
+    ["const", 6],
+    ["var", 7]
+  ]);
+  return [...codewiki.symbols].sort((a, b) => {
+    const rankCmp = (rank.get(a.kind) ?? 99) - (rank.get(b.kind) ?? 99);
+    return rankCmp || a.name.localeCompare(b.name) || a.fileId.localeCompare(b.fileId) || a.line - b.line;
+  }).slice(0, limit);
+}
+function dependencyLines(codewiki, limit) {
+  const fileById = new Map(codewiki.files.map((file) => [file.id, file]));
+  const byFile = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    const deps = byFile.get(edge.fileId) ?? { internal: [], external: [] };
+    if ("toFileId" in edge) {
+      const target = fileById.get(edge.toFileId);
+      if (target) deps.internal.push(target.path);
+    } else {
+      deps.external.push(edge.externalModule);
+    }
+    byFile.set(edge.fileId, deps);
+  }
+  return [...byFile.entries()].map(([fileId, deps]) => {
+    const file = fileById.get(fileId);
+    if (!file) return "";
+    const internal = [...new Set(deps.internal)].sort(compareStrings).slice(0, 4);
+    const external = [...new Set(deps.external)].sort(compareStrings).slice(0, 4);
+    return `- ${file.path}: internal=[${internal.join(", ")}] external=[${external.join(", ")}]`;
+  }).filter((line) => line.length > 0).sort(compareStrings).slice(0, limit);
+}
+function fitLines(lines, tokenBudget) {
+  const maxChars = Math.max(256, Math.floor(tokenBudget * 4));
+  const out = [];
+  let used = 0;
+  for (const line of lines) {
+    const next = used + line.length + 1;
+    if (next > maxChars) {
+      out.push("[digest truncated]");
+      break;
+    }
+    out.push(line);
+    used = next;
+  }
+  return out.join("\n");
+}
+function entryPointLine(file) {
+  const base = `- ${file.path} (${file.lang}, ${file.loc} loc)`;
+  return file.summary ? `${base}: ${file.summary.slice(0, 160)}` : base;
+}
+function renderCodewikiDigest(codewiki, tokenBudget = 1200) {
+  const files = sourceFiles(codewiki);
+  const areaCounts = countBy(files.map((file) => topTwoSegments(file.path))).slice(0, 10).map(([area, count]) => `${area}=${count}`);
+  const languageCounts = countBy(files.map((file) => file.lang)).map(([language, count]) => `${language}=${count}`).join(", ");
+  const roleCounts = countBy(files.map((file) => file.role)).map(([role, count]) => `${role}=${count}`).join(", ");
+  const fileById = new Map(codewiki.files.map((file) => [file.id, file]));
+  const lines = [
+    `codewiki v${codewiki.version} language=${codewiki.language} files=${files.length} configs=${codewiki.files.length - files.length} symbols=${codewiki.symbols.length} edges=${codewiki.edges.length}`,
+    `languages: ${languageCounts || "none"}`,
+    `roles: ${roleCounts || "none"}`,
+    `areas: ${areaCounts.join(", ") || "none"}`,
+    "entry points:",
+    ...entryPoints(codewiki, 12).map(entryPointLine),
+    "key symbols:",
+    ...keySymbols(codewiki, 40).map((symbol) => {
+      const file = fileById.get(symbol.fileId);
+      const location = file ? `${file.path}:${symbol.line}` : `${symbol.fileId}:${symbol.line}`;
+      return `- ${symbol.name} ${symbol.kind} ${location}`;
+    }),
+    "dependencies:",
+    ...dependencyLines(codewiki, 24)
+  ];
+  return fitLines(lines, tokenBudget);
+}
+
+export {
+  renderCodewikiDigest
+};
+//# sourceMappingURL=chunk-X3BR7HWV.js.map

package/dist/chunk-X3NE4WVW.js

@@ -0,0 +1,120 @@
+// src/core/xdg.ts
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+var cachedConfigDir;
+var cachedDataDir;
+var cachedStateDir;
+var cachedCacheDir;
+function envOrNull(key) {
+  const v = process.env[key]?.trim();
+  return v && v.length > 0 ? v : null;
+}
+function platformDefaults() {
+  const p = platform();
+  const h = homedir();
+  if (p === "win32") {
+    const appData = process.env.APPDATA ?? join(h, "AppData", "Roaming");
+    const localAppData = process.env.LOCALAPPDATA ?? join(h, "AppData", "Local");
+    return {
+      config: join(appData, "clio-coder", "config"),
+      data: join(appData, "clio-coder", "data"),
+      state: join(localAppData, "clio-coder", "state"),
+      cache: join(localAppData, "clio-coder", "cache")
+    };
+  }
+  if (p === "darwin") {
+    const base = join(h, "Library", "Application Support", "clio-coder");
+    return {
+      config: join(base, "config"),
+      data: join(base, "data"),
+      state: join(base, "state"),
+      cache: join(h, "Library", "Caches", "clio-coder")
+    };
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join(h, ".config");
+  const xdgData = process.env.XDG_DATA_HOME ?? join(h, ".local", "share");
+  const xdgState = process.env.XDG_STATE_HOME ?? join(h, ".local", "state");
+  const xdgCache = process.env.XDG_CACHE_HOME ?? join(h, ".cache");
+  return {
+    config: join(xdgConfig, "clio-coder"),
+    data: join(xdgData, "clio-coder"),
+    state: join(xdgState, "clio-coder"),
+    cache: join(xdgCache, "clio-coder")
+  };
+}
+function ensureDir(dir) {
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    const e = err;
+    if (e.code !== "EEXIST") throw err;
+  }
+  const s = statSync(dir);
+  if (!s.isDirectory()) throw new Error(`Expected directory at ${dir}`);
+  return dir;
+}
+function clioHomeOrNull() {
+  return envOrNull("CLIO_CODER_HOME");
+}
+function resolveRole(specificVar, role, defaults) {
+  const specific = envOrNull(specificVar);
+  if (specific) return specific;
+  const home = clioHomeOrNull();
+  if (home) return join(home, role);
+  return defaults[role];
+}
+function resolveClioDirs() {
+  const defaults = platformDefaults();
+  return {
+    config: resolveRole("CLIO_CODER_CONFIG_DIR", "config", defaults),
+    data: resolveRole("CLIO_CODER_DATA_DIR", "data", defaults),
+    state: resolveRole("CLIO_CODER_STATE_DIR", "state", defaults),
+    cache: resolveRole("CLIO_CODER_CACHE_DIR", "cache", defaults)
+  };
+}
+function clioConfigDir() {
+  if (cachedConfigDir) return cachedConfigDir;
+  cachedConfigDir = ensureDir(resolveClioDirs().config);
+  return cachedConfigDir;
+}
+function clioDataDir() {
+  if (cachedDataDir) return cachedDataDir;
+  cachedDataDir = ensureDir(resolveClioDirs().data);
+  return cachedDataDir;
+}
+function clioStateDir() {
+  if (cachedStateDir) return cachedStateDir;
+  cachedStateDir = ensureDir(resolveClioDirs().state);
+  return cachedStateDir;
+}
+function clioCacheDir() {
+  if (cachedCacheDir) return cachedCacheDir;
+  cachedCacheDir = ensureDir(resolveClioDirs().cache);
+  return cachedCacheDir;
+}
+function clioStatePath() {
+  return cachedStateDir ?? resolveClioDirs().state;
+}
+function stateRootRemoved() {
+  if (cachedStateDir === void 0) return false;
+  return !existsSync(cachedStateDir);
+}
+function resetXdgCache() {
+  cachedConfigDir = void 0;
+  cachedDataDir = void 0;
+  cachedStateDir = void 0;
+  cachedCacheDir = void 0;
+}
+
+export {
+  resolveClioDirs,
+  clioConfigDir,
+  clioDataDir,
+  clioStateDir,
+  clioCacheDir,
+  clioStatePath,
+  stateRootRemoved,
+  resetXdgCache
+};
+//# sourceMappingURL=chunk-X3NE4WVW.js.map