@iowarp/clio-coder 0.3.4 → 0.3.7

package/dist/{chunk-5M54SPOL.js → chunk-ODFEOB4F.js}

@@ -47,18 +47,16 @@ function truncateTail2(content, options = {}) {
   return truncateTail(content, withClioDefaults(options));
 }
 
-// src/tools/observation.ts
-init_esm_shims();
-
 // src/tools/result-shaping.ts
 init_esm_shims();
 import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, readdirSync, rmdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 
 // src/tools/result-disposition.ts
 init_esm_shims();
 import { createHash } from "node:crypto";
+var TOOL_RESULT_DIGEST_MAX_BYTES = 240;
 var ESSENTIAL_DETAIL_KEYS = /* @__PURE__ */ new Set([
   "aborted",
   "continuation",
@@ -158,6 +156,13 @@ function utf8Suffix(text, maxBytes) {
 function capUtf8(text, maxBytes) {
   return byteLength(text) <= maxBytes ? text : utf8Prefix(text, maxBytes);
 }
+function capDigestUtf8(text, maxBytes) {
+  if (byteLength(text) <= maxBytes) return text;
+  const marker = "\u2026";
+  const markerBytes = byteLength(marker);
+  if (markerBytes >= maxBytes) return utf8Prefix(text, maxBytes);
+  return `${utf8Prefix(text, maxBytes - markerBytes).trimEnd()}${marker}`;
+}
 function boundedToolResultExcerpt(text, maxBytes, bias = "head-tail") {
   if (maxBytes <= 0) return "";
   if (byteLength(text) <= maxBytes) return text;
@@ -349,6 +354,105 @@ ${trailer}`;
     truncated: byteLength(header) + 1 + byteLength(body) > maxBytes || !capturedTextIsComplete
   };
 }
+var DIGEST_FACT_KEYS = [
+  "outcome",
+  "exitCode",
+  "timedOut",
+  "aborted",
+  "outputCapped",
+  "signal",
+  "status",
+  "error",
+  "decision",
+  "next"
+];
+function digestFactText(details) {
+  if (details === void 0) return "";
+  const facts = [];
+  for (const key of DIGEST_FACT_KEYS) {
+    if (details[key] !== void 0) facts.push(`${key}=${stableJson(details[key])}`);
+  }
+  return facts.join(" ");
+}
+function projectionBody(input, projection) {
+  if (projection.appliedMode === "metadata-only") return "";
+  if (projection.appliedMode === "full") {
+    const trailer = fullTrailer(input);
+    return trailer.length > 0 && projection.text.endsWith(`
+
+${trailer}`) ? projection.text.slice(0, -(trailer.length + 2)) : projection.text;
+  }
+  const header = contextHeader(input, projection.appliedMode, projection.truncated, projection.summaryProvenance);
+  const prefix = `${header}
+`;
+  return projection.text.startsWith(prefix) ? projection.text.slice(prefix.length) : "";
+}
+function digestText(status, facts, body, redactions, maxBytes) {
+  const tally = createRedactionTally();
+  const safeStatus = redactSecretsText(status, tally);
+  const safeFacts = redactSecretsText(facts, tally);
+  const statusAndFacts = [safeStatus, safeFacts].filter((value) => value.length > 0).join(" ");
+  const bodyBudget = Math.max(0, maxBytes - byteLength(statusAndFacts) - 2);
+  const selected = deterministicDiagnosticSummary(body, bodyBudget, true);
+  const candidate = [statusAndFacts, selected.text.replace(/\s+/gu, " ").trim()].filter((value) => value.length > 0).join("; ");
+  return {
+    text: capDigestUtf8(candidate, maxBytes),
+    redactions: redactions + tally.count + selected.redactions
+  };
+}
+function deterministicToolResultDigest(input, maxBytes = TOOL_RESULT_DIGEST_MAX_BYTES) {
+  const projection = projectToolResultContext(input);
+  const status = [
+    `kind=${input.kind}`,
+    `mode=${projection.appliedMode}`,
+    `truncated=${String(projection.truncated)}`,
+    ...projection.appliedMode === "metadata-only" || projection.truncated ? [`capturedBytes=${input.capturedBytes}`] : []
+  ].join(" ");
+  const digest = digestText(
+    status,
+    digestFactText(input.details),
+    projectionBody(input, projection),
+    projection.summaryProvenance?.redactions ?? 0,
+    Math.max(1, Math.floor(maxBytes))
+  );
+  return {
+    text: digest.text,
+    provenance: {
+      producer: "code",
+      source: "canonical-result-disposition",
+      algorithm: "redacted-context-digest-v1",
+      contextMode: projection.appliedMode,
+      ...projection.summaryProvenance === void 0 ? {} : { summaryAlgorithm: projection.summaryProvenance.algorithm },
+      ...digest.redactions > 0 ? { redactions: digest.redactions } : {}
+    }
+  };
+}
+function legacyToolResultDigest(text, options) {
+  const maxBytes = Math.max(1, Math.floor(options.maxBytes ?? TOOL_RESULT_DIGEST_MAX_BYTES));
+  const fallback = options.outcome === "error" && text.trim().length === 0 ? "an unknown tool error" : text;
+  const digest = digestText("", "", fallback, 0, maxBytes);
+  return {
+    text: digest.text,
+    provenance: {
+      producer: "code",
+      source: "legacy-fallback",
+      algorithm: "redacted-legacy-digest-v1",
+      ...digest.redactions > 0 ? { redactions: digest.redactions } : {}
+    }
+  };
+}
+function sanitizeToolResultDigest(digest, maxBytes = TOOL_RESULT_DIGEST_MAX_BYTES) {
+  const tally = createRedactionTally();
+  const safe = redactSecretsText(digest.text, tally).replace(/\s+/gu, " ").trim();
+  const redactions = (digest.provenance.redactions ?? 0) + tally.count;
+  return {
+    text: capDigestUtf8(safe, Math.max(1, Math.floor(maxBytes))),
+    provenance: {
+      ...digest.provenance,
+      ...redactions > 0 ? { redactions } : {}
+    }
+  };
+}
 function toolResultContextText(result) {
   if (result.modelContext !== void 0) return result.modelContext;
   return result.kind === "ok" ? result.output : result.message;
@@ -387,6 +491,7 @@ var DEFAULT_TOOL_RESULT_MAX_BYTES = DEFAULT_MAX_BYTES + 2 * 1024;
 var RESULT_TRUNCATION_MARKER = "\n[tool result truncated]";
 var RESULT_OFFLOAD_MAX_BYTES = 10 * 1024 * 1024;
 var TAIL_NOTICE_RESERVE_BYTES = 512;
+var TOOL_OFFLOAD_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
 function mergeDetails(details, resultSize) {
   return { ...details ?? {}, resultSize };
 }
@@ -401,6 +506,25 @@ function offloadMaxBytesFor(spec) {
   const configured = spec.metadata?.resultSizePolicy?.offloadMaxBytes;
   return typeof configured === "number" && Number.isFinite(configured) && configured > 0 ? Math.floor(configured) : RESULT_OFFLOAD_MAX_BYTES;
 }
+function toolResultDigestFor(spec, result, requestedDisposition) {
+  const text = resultText(result);
+  const disposition = normalizeToolResultDisposition(spec, maxBytesFor(spec), requestedDisposition);
+  if (disposition === null) {
+    const projected = shapeLegacyToolResult(spec, result);
+    return legacyToolResultDigest(resultText(projected), { outcome: result.kind });
+  }
+  const capturedBytes = capturedBytesFor(result, text);
+  return deterministicToolResultDigest({
+    text,
+    kind: result.kind,
+    details: result.details,
+    disposition,
+    capturedBytes,
+    displayedBytes: Math.min(capturedBytes, disposition.presentation.maxBytes),
+    offloadPath: existingOffloadPath(result.details),
+    followUpHint: followUpHint(spec)
+  });
+}
 function detailsRecord(details, key) {
   const candidate = details?.[key];
   return candidate !== null && typeof candidate === "object" && !Array.isArray(candidate) ? candidate : null;
@@ -426,6 +550,33 @@ function offloadBody(text, bytes, maxBytes) {
   const prefixBudget = maxBytes - byteLength(notice);
   return `${truncateUtf8(text, Math.max(0, prefixBudget), "")}${notice}`;
 }
+function sweepExpiredToolOffloads(now = Date.now()) {
+  const root = join(clioStateDir(), "scratch");
+  const cutoff = now - TOOL_OFFLOAD_MAX_AGE_MS;
+  let removed = 0;
+  try {
+    for (const session of readdirSync(root, { withFileTypes: true })) {
+      if (!session.isDirectory()) continue;
+      const sessionDir = join(root, session.name);
+      for (const entry of readdirSync(sessionDir, { withFileTypes: true })) {
+        if (!entry.isFile()) continue;
+        const path = join(sessionDir, entry.name);
+        try {
+          if (statSync(path).mtimeMs >= cutoff) continue;
+          rmSync(path, { force: true });
+          removed += 1;
+        } catch {
+        }
+      }
+      try {
+        if (readdirSync(sessionDir).length === 0) rmdirSync(sessionDir);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return removed;
+}
 function writeToolOffload(text, context, maxBytes = RESULT_OFFLOAD_MAX_BYTES, digest = createHash2("sha256").update(text).digest("hex")) {
   try {
     const bytes = byteLength(text);
@@ -673,6 +824,7 @@ function shapeToolResult(spec, result, context, requestedDisposition) {
 }
 
 // src/tools/observation.ts
+init_esm_shims();
 var OBSERVATION_POLICY_SLACK_BYTES = 2 * 1024;
 var OBSERVE_SELF_CAPS = {
   grepContent: 16 * 1024,
@@ -904,6 +1056,8 @@ ${limitedBudgetNote(input.reservation)}`;
 
 export {
   deterministicDiagnosticSummary,
+  legacyToolResultDigest,
+  sanitizeToolResultDigest,
   toolResultContextText,
   isDispositionedToolResultError,
   toolResultPresentationText,
@@ -913,6 +1067,8 @@ export {
   truncateHead2 as truncateHead,
   truncateTail2 as truncateTail,
   DEFAULT_TOOL_RESULT_MAX_BYTES,
+  toolResultDigestFor,
+  sweepExpiredToolOffloads,
   isSessionOffloadPath,
   shapeToolResult,
   OBSERVATION_POLICY_SLACK_BYTES,
@@ -923,4 +1079,4 @@ export {
   observationBudgetExhausted,
   finalizeObservation
 };
-//# sourceMappingURL=chunk-5M54SPOL.js.map
+//# sourceMappingURL=chunk-ODFEOB4F.js.map

package/dist/chunk-PD3MESLB.js

@@ -0,0 +1,242 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  runVectorTool
+} from "./chunk-JNXPYBB4.js";
+import {
+  PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
+  loadProjectVerifierCatalog,
+  packageDeclaredCheck,
+  resolveProjectVerifierExecutionCwd
+} from "./chunk-GH5622CP.js";
+import {
+  declaredVerificationScripts
+} from "./chunk-UL3WSD3F.js";
+import {
+  resolveSafeCwd
+} from "./chunk-D4MDIG46.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/verify/scripts.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+function repositoryRelativeCwd(workspaceRoot, resolved) {
+  const relative = path.relative(workspaceRoot, resolved);
+  return relative.length === 0 ? "." : relative.split(path.sep).join("/");
+}
+function packageTag(id) {
+  const separator = id.search(/[:.-]/u);
+  return [separator === -1 ? id : id.slice(0, separator)];
+}
+function packageCheckSource(packageRoot, workspaceRoot) {
+  const packagePath = path.join(packageRoot, "package.json");
+  if (!existsSync(packagePath)) return null;
+  const pkg = parsePackageJson(packagePath);
+  if (!pkg.ok) return null;
+  const cwd = repositoryRelativeCwd(workspaceRoot, packageRoot);
+  const checks = declaredVerificationScripts(pkg.scripts).map(
+    (id) => packageDeclaredCheck(id, packagePath, cwd, packageTag(id))
+  );
+  return { kind: "package.json", path: packagePath, checks };
+}
+function discoverDeclaredProjectEntriesAtRoot(workspaceRoot) {
+  const entries = [];
+  const packagePath = path.join(workspaceRoot, "package.json");
+  if (existsSync(packagePath)) {
+    const pkg = parsePackageJson(packagePath);
+    if (pkg.ok) {
+      for (const name of Object.keys(pkg.scripts).sort()) {
+        if (typeof pkg.scripts[name] !== "string") continue;
+        entries.push({
+          id: name,
+          command: ["npm", "run", name],
+          path: "package.json",
+          detail: `package.json script '${name}'`,
+          kind: "package-script"
+        });
+      }
+    }
+  }
+  for (const relative of ["justfile", "Justfile"]) {
+    const filePath = path.join(workspaceRoot, relative);
+    if (!existsSync(filePath)) continue;
+    const text = readFileSync(filePath, "utf8");
+    for (const match of text.matchAll(/^([A-Za-z0-9][A-Za-z0-9_-]*)\s*(?:[^:=\n]*)?:\s*(?:#.*)?$/gmu)) {
+      const name = match[1];
+      if (name === void 0 || name.startsWith("_")) continue;
+      entries.push({
+        id: name,
+        command: ["just", name],
+        path: relative,
+        detail: `just recipe '${name}'`,
+        kind: "just-recipe"
+      });
+    }
+    break;
+  }
+  const makePath = path.join(workspaceRoot, "Makefile");
+  if (existsSync(makePath)) {
+    const text = readFileSync(makePath, "utf8");
+    for (const match of text.matchAll(/^([A-Za-z0-9][A-Za-z0-9_.-]*)\s*:(?![=])[^\n]*$/gmu)) {
+      const name = match[1];
+      if (name === void 0 || name.startsWith(".")) continue;
+      entries.push({
+        id: name,
+        command: ["make", name],
+        path: "Makefile",
+        detail: `Makefile target '${name}'`,
+        kind: "make-target"
+      });
+    }
+  }
+  return entries;
+}
+function providerCollision(sources) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    for (const check of source.checks) {
+      const prior = seen.get(check.id);
+      if (prior !== void 0) {
+        return `duplicate declared check id '${check.id}' from ${prior.source.kind} (${prior.source.path}) and ${check.source.kind} (${check.source.path})`;
+      }
+      seen.set(check.id, check);
+    }
+  }
+  return null;
+}
+function discoverDeclaredChecksAtRoot(workspaceRoot, cwdArg) {
+  let packageRoot;
+  try {
+    packageRoot = resolveSafeCwd(cwdArg, workspaceRoot);
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+  const sources = [];
+  const packageSource = packageCheckSource(packageRoot, workspaceRoot);
+  if (packageSource !== null) sources.push(packageSource);
+  const projectCatalog = loadProjectVerifierCatalog(workspaceRoot);
+  if (!projectCatalog.ok) return projectCatalog;
+  if (projectCatalog.source !== null) sources.push(projectCatalog.source);
+  const collision = providerCollision(sources);
+  if (collision !== null) return { ok: false, reason: collision };
+  return { ok: true, sources };
+}
+function discoverDeclaredChecks(cwdArg) {
+  return discoverDeclaredChecksAtRoot(process.cwd(), cwdArg);
+}
+function clonedSources(sources) {
+  return sources.map((source) => ({
+    kind: source.kind,
+    path: source.path,
+    checks: source.checks.map((check) => ({
+      ...check,
+      command: [...check.command],
+      tags: [...check.tags],
+      source: { ...check.source }
+    }))
+  }));
+}
+function listChecks(cwdArg) {
+  const discovery = discoverDeclaredChecks(cwdArg);
+  if (!discovery.ok) return { kind: "error", message: `verify: ${discovery.reason}` };
+  const lines = [];
+  if (discovery.sources.length === 0 || discovery.sources.every((source) => source.checks.length === 0)) {
+    lines.push(
+      `No declared verification checks found (no package.json verification scripts or ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH} entries).`,
+      "Run `clio-coder verifiers author` to inspect declared project tooling, preview exact argv checks, and create the catalog after confirmation."
+    );
+  } else {
+    lines.push("Declared verification checks:");
+    for (const source of discovery.sources) {
+      lines.push(source.kind === "package.json" ? "package.json:" : `${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH}:`);
+      for (const check of source.checks) {
+        const tags = check.tags.length > 0 ? ` [${check.tags.join(", ")}]` : "";
+        lines.push(`- ${check.id}${tags}: ${check.description}`);
+      }
+    }
+  }
+  lines.push(
+    "",
+    'Run one with verify(check="<id>"). verify(check="frontend", path=<file>) validates an HTML/CSS/JS artifact.'
+  );
+  return {
+    kind: "ok",
+    output: lines.join("\n"),
+    details: { sources: clonedSources(discovery.sources) }
+  };
+}
+function withDeclaredEvidence(result, check) {
+  return {
+    ...result,
+    details: {
+      ...result.details,
+      action: "verify",
+      check: check.id,
+      source: { ...check.source },
+      description: check.description,
+      declaredCommand: [...check.command],
+      declaredCwd: check.cwd,
+      declaredTimeoutMs: check.timeoutMs,
+      tags: [...check.tags]
+    }
+  };
+}
+async function runProjectCheck(check, options) {
+  const [file, ...vector] = check.command;
+  if (file === void 0) return { kind: "error", message: `verify: declared check '${check.id}' has empty argv` };
+  const cwd = resolveProjectVerifierExecutionCwd(check.cwd, process.cwd());
+  if (cwd instanceof Error) return { kind: "error", message: `verify: ${cwd.message}` };
+  const result = await runVectorTool("verify", file, vector, { cwd, timeout_ms: check.timeoutMs }, options);
+  return withDeclaredEvidence(result, check);
+}
+async function runScriptCheck(check, args, options) {
+  let cwd;
+  try {
+    cwd = resolveSafeCwd(typeof args.cwd === "string" && args.cwd.length > 0 ? args.cwd : void 0, process.cwd());
+  } catch (error) {
+    return { kind: "error", message: `verify: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const packagePath = path.join(cwd, "package.json");
+  if (!existsSync(packagePath)) return { kind: "error", message: `verify: package.json not found in ${cwd}` };
+  const pkg = parsePackageJson(packagePath);
+  if (!pkg.ok) return { kind: "error", message: `verify: ${pkg.reason}` };
+  if (!Object.hasOwn(pkg.scripts, check)) {
+    const declared = declaredVerificationScripts(pkg.scripts);
+    const list = declared.length > 0 ? declared.join(", ") : "(none)";
+    return {
+      kind: "error",
+      message: `verify: package.json has no '${check}' script. Declared verification checks: ${list}.`
+    };
+  }
+  const extraArgs = Array.isArray(args.args) ? args.args.filter((entry) => typeof entry === "string") : [];
+  const vector = ["run", check];
+  if (extraArgs.length > 0) vector.push("--", ...extraArgs);
+  return runVectorTool("verify", "npm", vector, { ...args, cwd }, options);
+}
+function parsePackageJson(packagePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { ok: false, reason: "package.json root must be an object" };
+    }
+    const scripts = parsed.scripts;
+    if (!scripts || typeof scripts !== "object" || Array.isArray(scripts)) {
+      return { ok: false, reason: "package.json has no scripts object" };
+    }
+    return { ok: true, scripts };
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export {
+  discoverDeclaredProjectEntriesAtRoot,
+  discoverDeclaredChecksAtRoot,
+  discoverDeclaredChecks,
+  listChecks,
+  runProjectCheck,
+  runScriptCheck
+};
+//# sourceMappingURL=chunk-PD3MESLB.js.map

package/dist/{chunk-ED4KHGC3.js → chunk-PPAMZ32Z.js}

@@ -65,6 +65,13 @@ function globalFlagPositionHint(arg, command) {
   if (usage === void 0) return null;
   return `${arg} is a global option and must come before the subcommand: clio-coder ${usage} ${command} ...`;
 }
+function unknownGlobalOptionError(arg) {
+  const bare = arg.replace(/=.*$/u, "");
+  if (bare === "--resume" || bare === "--continue" || bare === "-r" || bare === "-c") {
+    return `unknown global option: ${arg}. Sessions are resumed from inside the app: start clio-coder, then type /resume to pick one.`;
+  }
+  return `unknown global option: ${arg}`;
+}
 function extractGlobalFlags(argv, isSubcommand = () => false) {
   const rest = [];
   let apiKey;
@@ -116,7 +123,7 @@ function extractGlobalFlags(argv, isSubcommand = () => false) {
       noSkills,
       skillPaths,
       rest,
-      error: `unknown global option: ${arg}`,
+      error: unknownGlobalOptionError(arg),
       ...apiKey === void 0 ? {} : { apiKey }
     };
   }
@@ -140,4 +147,4 @@ export {
   globalFlagPositionHint,
   extractGlobalFlags
 };
-//# sourceMappingURL=chunk-ED4KHGC3.js.map
+//# sourceMappingURL=chunk-PPAMZ32Z.js.map