@iowarp/clio-coder 0.3.0

package/dist/chunk-QV47YRF4.js

@@ -0,0 +1,48 @@
+// src/core/tool-names.ts
+var ToolNames = {
+  // OBSERVE
+  Read: "read",
+  Grep: "grep",
+  Find: "find",
+  Ls: "ls",
+  CodeNav: "code_nav",
+  Context: "context",
+  CredentialPresent: "credential_present",
+  // MUTATE
+  Write: "write",
+  Edit: "edit",
+  // EXECUTE
+  Bash: "bash",
+  Git: "git",
+  Verify: "verify",
+  // ORCHESTRATE
+  Dispatch: "dispatch",
+  Monitor: "monitor",
+  Steer: "steer",
+  Tasks: "tasks",
+  Ledger: "ledger",
+  // RETRIEVE
+  WebFetch: "web_fetch",
+  // INTERACT
+  AskUser: "ask_user",
+  // ARTIFACT
+  Artifact: "artifact"
+  // DESIGN-RESERVED, not implemented: gateway, the MCP/DB proxy. One fixed
+  // schema; external capabilities are surfaced through find/describe/call
+  // RESULTS, never as per-capability schemas in the prompt prefix. Contract
+  // sketch: gateway(op: "find" | "describe" | "call", capability?, args?)
+  // -> JSON capability listings / schemas / call results, network action
+  // class, sequential. Reserving the name here keeps classifiers and
+  // profiles from ever assigning "gateway" to a dynamic tool.
+  // Gateway: "gateway",
+};
+var ALL_TOOL_NAMES = Object.values(ToolNames);
+function isBuiltinToolName(name) {
+  return ALL_TOOL_NAMES.includes(name);
+}
+
+export {
+  ToolNames,
+  isBuiltinToolName
+};
+//# sourceMappingURL=chunk-QV47YRF4.js.map

package/dist/chunk-RQDWMVRB.js

@@ -0,0 +1,279 @@
+import {
+  WORKSPACE_EXCLUDED_DIRS,
+  createSlicer,
+  enumerateWorkspaceFiles,
+  enumerateWorkspaceFilesAsync,
+  isIndexablePath,
+  readCodewiki,
+  readCodewikiAsync
+} from "./chunk-TPOCL34A.js";
+import {
+  safeResourceWrite
+} from "./chunk-VPAWTYLY.js";
+
+// src/domains/context/fingerprint.ts
+import { execFile, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var DEFAULT_FINGERPRINT_CACHE_TTL_MS = 5e3;
+var cachedFingerprints = /* @__PURE__ */ new Map();
+var LOC_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rs",
+  ".go",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".hpp",
+  ".hh",
+  ".hxx",
+  ".c",
+  ".h",
+  ".cu",
+  ".cuh",
+  ".java",
+  ".kt"
+]);
+function extensionOf(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function currentGitHead(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+async function currentGitHeadAsync(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd, encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function countLines(filePath) {
+  try {
+    const text = readFileSync(filePath, "utf8");
+    if (text.length === 0) return 0;
+    let lines = 1;
+    for (const ch of text) {
+      if (ch === "\n") lines += 1;
+    }
+    return lines;
+  } catch {
+    return 0;
+  }
+}
+function locFromCodewiki(codewiki) {
+  if (!codewiki) return null;
+  return codewiki.files.reduce((sum, file) => file.lang === "config" ? sum : sum + file.loc, 0);
+}
+function accumulateFile(cwd, relPath, hash, artifactLoc) {
+  const absPath = join(cwd, relPath);
+  let stat;
+  try {
+    stat = statSync(absPath);
+  } catch {
+    return 0;
+  }
+  hash.update(`${relPath}:${stat.size}:${Math.floor(stat.mtimeMs)}
+`);
+  if (artifactLoc === null && LOC_EXTENSIONS.has(extensionOf(relPath))) return countLines(absPath);
+  return 0;
+}
+function computeFingerprint(cwd, codewiki = readCodewiki(cwd)) {
+  const files = enumerateWorkspaceFiles(cwd, WORKSPACE_EXCLUDED_DIRS).filter(isIndexablePath);
+  const hash = createHash("sha256");
+  const artifactLoc = locFromCodewiki(codewiki);
+  let loc = 0;
+  for (const relPath of files) loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+  return {
+    treeHash: hash.digest("hex"),
+    gitHead: currentGitHead(cwd),
+    loc: artifactLoc ?? loc
+  };
+}
+async function computeFingerprintAsync(cwd, codewiki = void 0, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const artifact = codewiki === void 0 ? await readCodewikiAsync(cwd) : codewiki;
+  await slicer.tick();
+  const files = (await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(isIndexablePath);
+  const hash = createHash("sha256");
+  const artifactLoc = locFromCodewiki(artifact);
+  let loc = 0;
+  for (const relPath of files) {
+    await slicer.tick();
+    loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+  }
+  return {
+    treeHash: hash.digest("hex"),
+    gitHead: await currentGitHeadAsync(cwd),
+    loc: artifactLoc ?? loc
+  };
+}
+function computeFingerprintCached(cwd, codewiki = readCodewiki(cwd), options = {}) {
+  const now = Date.now();
+  const cached = cachedFingerprints.get(cwd);
+  if (cached && cached.expiresAtMs > now) return cached.fingerprint;
+  const fingerprint = computeFingerprint(cwd, codewiki);
+  const ttlMs = options.ttlMs ?? DEFAULT_FINGERPRINT_CACHE_TTL_MS;
+  cachedFingerprints.set(cwd, {
+    fingerprint,
+    expiresAtMs: Date.now() + Math.max(0, ttlMs)
+  });
+  return fingerprint;
+}
+function isStale(prev, curr) {
+  return prev.treeHash !== curr.treeHash;
+}
+
+// src/domains/context/state.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var LEGACY_BOOTSTRAP_GENERATION_MODE = "scout";
+var STATE_RELATIVE_PATH = ".clio-coder/state.json";
+var BOOTSTRAP_GENERATION_MODES = /* @__PURE__ */ new Set(["model", "heuristic", "existing"]);
+var BOOTSTRAP_PARSER_OUTCOMES = /* @__PURE__ */ new Set(["parsed", "rejected", "not-run"]);
+var BOOTSTRAP_FALLBACK_REASON_MAX_LENGTH = 4096;
+var BOOTSTRAP_GENERATION_KEYS = /* @__PURE__ */ new Set([
+  "mode",
+  "parserOutcome",
+  "fallbackReason",
+  "structuredOutputMode",
+  "runId",
+  "targetId",
+  "wireModelId",
+  "runtimeId",
+  "runtimeKind",
+  "thinkingLevel",
+  "tokenCount",
+  "toolCalls",
+  "durationMs",
+  "promptBytes",
+  "outputBytes"
+]);
+var BOOTSTRAP_ID_KEYS = ["runId", "targetId", "wireModelId", "runtimeId", "runtimeKind", "thinkingLevel"];
+var BOOTSTRAP_COUNTER_KEYS = ["tokenCount", "toolCalls", "durationMs", "promptBytes", "outputBytes"];
+function isBoundedNonemptyString(value, maxLength) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= maxLength;
+}
+function isNonemptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isBootstrapGenerationState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  if (!Object.keys(obj).every((key) => BOOTSTRAP_GENERATION_KEYS.has(key))) return false;
+  if (typeof obj.mode !== "string" || !BOOTSTRAP_GENERATION_MODES.has(obj.mode)) {
+    return false;
+  }
+  if (typeof obj.parserOutcome !== "string" || !BOOTSTRAP_PARSER_OUTCOMES.has(obj.parserOutcome)) {
+    return false;
+  }
+  if (obj.fallbackReason !== void 0 && !isBoundedNonemptyString(obj.fallbackReason, BOOTSTRAP_FALLBACK_REASON_MAX_LENGTH)) {
+    return false;
+  }
+  if (obj.structuredOutputMode !== void 0 && obj.structuredOutputMode !== "native-schema" && obj.structuredOutputMode !== "prompt-parser") {
+    return false;
+  }
+  for (const key of BOOTSTRAP_ID_KEYS) {
+    if (obj[key] !== void 0 && !isNonemptyString(obj[key])) return false;
+  }
+  for (const key of BOOTSTRAP_COUNTER_KEYS) {
+    if (obj[key] !== void 0 && (!Number.isSafeInteger(obj[key]) || obj[key] < 0)) return false;
+  }
+  return true;
+}
+function isFingerprint(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  return typeof obj.treeHash === "string" && /^[0-9a-f]{64}$/.test(obj.treeHash) && (typeof obj.gitHead === "string" || obj.gitHead === null) && typeof obj.loc === "number" && Number.isInteger(obj.loc) && obj.loc >= 0;
+}
+var ADOPTION_SCOPES = /* @__PURE__ */ new Set(["project", "global"]);
+var ADOPTION_PROVIDERS = /* @__PURE__ */ new Set([
+  "claude-code",
+  "agents",
+  "codex",
+  "gemini",
+  "cursor",
+  "copilot",
+  "opencode"
+]);
+var ADOPTION_KINDS = /* @__PURE__ */ new Set(["instructions", "settings", "command", "agent", "skill", "rule"]);
+function isContextSourceSnapshot(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  return typeof obj.path === "string" && obj.path.length > 0 && typeof obj.scope === "string" && ADOPTION_SCOPES.has(obj.scope) && typeof obj.provider === "string" && ADOPTION_PROVIDERS.has(obj.provider) && typeof obj.kind === "string" && ADOPTION_KINDS.has(obj.kind) && (obj.directoryScope === void 0 || typeof obj.directoryScope === "string" && obj.directoryScope.trim().length > 0 && obj.directoryScope.length <= 512) && typeof obj.sha256 === "string" && /^[0-9a-f]{64}$/.test(obj.sha256) && (obj.status === void 0 || obj.status === "accepted" || obj.status === "rejected") && (obj.reason === void 0 || isBoundedNonemptyString(obj.reason, 256)) && (obj.status !== "rejected" || typeof obj.reason === "string");
+}
+function isProjectState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const obj = value;
+  if (obj.version !== 1 || !isFingerprint(obj.fingerprint)) return false;
+  if ("bootstrapFingerprint" in obj && obj.bootstrapFingerprint !== void 0 && !isFingerprint(obj.bootstrapFingerprint)) {
+    return false;
+  }
+  if ("lastBootstrap" in obj && obj.lastBootstrap !== void 0 && !isBootstrapGenerationState(obj.lastBootstrap)) {
+    return false;
+  }
+  if ("codewikiVersion" in obj && obj.codewikiVersion !== void 0 && (typeof obj.codewikiVersion !== "number" || !Number.isInteger(obj.codewikiVersion) || obj.codewikiVersion < 1)) {
+    return false;
+  }
+  if ("contextSources" in obj && obj.contextSources !== void 0) {
+    if (!Array.isArray(obj.contextSources) || !obj.contextSources.every(isContextSourceSnapshot)) return false;
+  }
+  if ("contextSourceHash" in obj && obj.contextSourceHash !== void 0 && (typeof obj.contextSourceHash !== "string" || !/^[0-9a-f]{64}$/.test(obj.contextSourceHash))) {
+    return false;
+  }
+  return true;
+}
+function statePath(cwd) {
+  return join2(cwd, STATE_RELATIVE_PATH);
+}
+function migrateLegacyGenerationMode(parsed) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
+  const last = parsed.lastBootstrap;
+  if (typeof last !== "object" || last === null || Array.isArray(last)) return;
+  const record = last;
+  if (record.mode === LEGACY_BOOTSTRAP_GENERATION_MODE) record.mode = "model";
+}
+function readClioState(cwd) {
+  const filePath = statePath(cwd);
+  if (!existsSync(filePath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+  migrateLegacyGenerationMode(parsed);
+  return isProjectState(parsed) ? parsed : null;
+}
+function writeClioState(cwd, state) {
+  safeResourceWrite(statePath(cwd), `${JSON.stringify(state, null, 2)}
+`, { encoding: "utf8" });
+}
+
+export {
+  computeFingerprint,
+  computeFingerprintAsync,
+  computeFingerprintCached,
+  isStale,
+  statePath,
+  readClioState,
+  writeClioState
+};
+//# sourceMappingURL=chunk-RQDWMVRB.js.map

package/dist/chunk-TFSSEXL6.js

@@ -0,0 +1,136 @@
+import {
+  DEFAULT_SETTINGS_YAML
+} from "./chunk-UHTSULZS.js";
+import {
+  clioCacheDir,
+  clioConfigDir,
+  clioDataDir,
+  clioStateDir,
+  resolveClioDirs
+} from "./chunk-X3NE4WVW.js";
+import {
+  readClioVersion
+} from "./chunk-DXQNI4PC.js";
+
+// src/core/init.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var CONFIG_SUBDIRS = ["agents"];
+var DATA_SUBDIRS = ["memory", "evidence", "evals"];
+var STATE_SUBDIRS = ["sessions", "audit", "receipts", "interviews", "scratch"];
+function initializeClioHome() {
+  enforceHomePrefixGuard();
+  const resolved = resolveClioDirs();
+  const preexistingHome = existsSync(resolved.state) || existsSync(resolved.config) || existsSync(resolved.data);
+  const configDir = clioConfigDir();
+  const dataDir = clioDataDir();
+  const stateDir = clioStateDir();
+  const cacheDir = clioCacheDir();
+  const created = [];
+  for (const dir of [configDir, dataDir, stateDir, cacheDir]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+      created.push(dir);
+    }
+  }
+  const subdirSets = [
+    [configDir, CONFIG_SUBDIRS],
+    [dataDir, DATA_SUBDIRS],
+    [stateDir, STATE_SUBDIRS]
+  ];
+  for (const [root, subs] of subdirSets) {
+    for (const sub of subs) {
+      const full = join(root, sub);
+      if (!existsSync(full)) {
+        mkdirSync(full, { recursive: true });
+        created.push(full);
+      }
+    }
+  }
+  const settingsPath = join(configDir, "settings.yaml");
+  let touched = false;
+  if (!existsSync(settingsPath)) {
+    writeFileSync(settingsPath, DEFAULT_SETTINGS_YAML, { encoding: "utf8", mode: 420 });
+    created.push(settingsPath);
+    touched = true;
+  }
+  const credentialsPath = join(configDir, "credentials.yaml");
+  if (!existsSync(credentialsPath)) {
+    writeFileSync(
+      credentialsPath,
+      "# Managed via `clio-coder auth`. Do not edit manually unless you know what you are doing.\n{}\n",
+      {
+        encoding: "utf8",
+        mode: 384
+      }
+    );
+    chmodSync(credentialsPath, 384);
+    created.push(credentialsPath);
+  }
+  const installPath = join(stateDir, "install.json");
+  const installMetadata = readInstallMetadata(installPath);
+  const currentVersion = readClioVersion();
+  if (!installMetadata) {
+    const payload = {
+      version: currentVersion,
+      // A first install knows when it happened. A repair does not, and saying
+      // `installedAt: now` there is a fact this process invented.
+      ...preexistingHome ? { repairedAt: (/* @__PURE__ */ new Date()).toISOString() } : { installedAt: (/* @__PURE__ */ new Date()).toISOString() },
+      platform: process.platform,
+      nodeVersion: process.version
+    };
+    writeFileSync(installPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+    created.push(installPath);
+  } else if (installMetadata.version !== currentVersion || installMetadata.platform !== process.platform || installMetadata.nodeVersion !== process.version) {
+    const payload = {
+      version: currentVersion,
+      ...installMetadata.installedAt !== void 0 ? { installedAt: installMetadata.installedAt } : {},
+      ...installMetadata.repairedAt !== void 0 ? { repairedAt: installMetadata.repairedAt } : {},
+      upgradedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      platform: process.platform,
+      nodeVersion: process.version
+    };
+    writeFileSync(installPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  }
+  return { configDir, dataDir, stateDir, cacheDir, createdPaths: created, touchedSettings: touched };
+}
+function readInstallMetadata(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.version === "string" && (typeof parsed.installedAt === "string" || typeof parsed.repairedAt === "string") && typeof parsed.platform === "string" && typeof parsed.nodeVersion === "string") {
+      return {
+        version: parsed.version,
+        ...typeof parsed.installedAt === "string" ? { installedAt: parsed.installedAt } : {},
+        ...typeof parsed.upgradedAt === "string" ? { upgradedAt: parsed.upgradedAt } : {},
+        ...typeof parsed.repairedAt === "string" ? { repairedAt: parsed.repairedAt } : {},
+        platform: parsed.platform,
+        nodeVersion: parsed.nodeVersion
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function enforceHomePrefixGuard() {
+  if (process.env.CLIO_CODER_REQUIRE_HOME_PREFIX !== "1") return;
+  const home = process.env.CLIO_CODER_HOME?.trim();
+  if (!home) return;
+  const dirs = resolveClioDirs();
+  const offenders = [];
+  if (!dirs.config.startsWith(home)) offenders.push(`configDir=${dirs.config}`);
+  if (!dirs.data.startsWith(home)) offenders.push(`dataDir=${dirs.data}`);
+  if (!dirs.state.startsWith(home)) offenders.push(`stateDir=${dirs.state}`);
+  if (!dirs.cache.startsWith(home)) offenders.push(`cacheDir=${dirs.cache}`);
+  if (offenders.length === 0) return;
+  throw new Error(
+    `CLIO_CODER_REQUIRE_HOME_PREFIX guardrail tripped: resolved Clio directories escape CLIO_CODER_HOME=${home}. Offending paths: ${offenders.join(", ")}. Individual overrides CLIO_CODER_CONFIG_DIR, CLIO_CODER_DATA_DIR, CLIO_CODER_STATE_DIR, and CLIO_CODER_CACHE_DIR take precedence over CLIO_CODER_HOME, so a test that sets only CLIO_CODER_HOME inherits whatever the parent process configured. Override all five env vars in lockstep to scratch subdirs (CLIO_CODER_HOME plus CLIO_CODER_CONFIG_DIR, CLIO_CODER_DATA_DIR, CLIO_CODER_STATE_DIR, CLIO_CODER_CACHE_DIR pointing under it), then call resetXdgCache().`
+  );
+}
+
+export {
+  initializeClioHome
+};
+//# sourceMappingURL=chunk-TFSSEXL6.js.map