@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-ARBGF5F7.js

@@ -0,0 +1,174 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  VERIFICATION_SCRIPT_FAMILY_HINT
+} from "./chunk-7MNJORFF.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
+  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+  combineSafeOutput,
+  runCommandVector
+} from "./chunk-SRF2PJNW.js";
+import {
+  StringEnum
+} from "./chunk-FCSXB6T2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/verify/surface.ts
+init_esm_shims();
+var BROWSER_MODES = ["auto", "required", "off"];
+function prepareVerifyArguments(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+  const next = { ...args };
+  if (typeof next.args === "string") {
+    try {
+      const parsed = JSON.parse(next.args);
+      if (Array.isArray(parsed)) next.args = parsed;
+    } catch {
+    }
+  }
+  return next;
+}
+var verifyToolSurface = {
+  name: ToolNames.Verify,
+  description: 'Run a declared verification check: no arguments lists checks, check=<package.json script> runs it, check="frontend" with path validates an HTML/CSS/JS artifact.',
+  parameters: typebox_exports.Object({
+    check: typebox_exports.Optional(
+      typebox_exports.String({
+        description: `Declared script name (${VERIFICATION_SCRIPT_FAMILY_HINT}) or "frontend". Omit to list available checks.`
+      })
+    ),
+    path: typebox_exports.Optional(typebox_exports.String({ description: "check=frontend: artifact file under the workspace root." })),
+    args: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String(), { description: "Extra arguments passed after --." })),
+    browser: typebox_exports.Optional(
+      StringEnum(BROWSER_MODES, { description: "check=frontend: headless browser mode (default auto)." })
+    ),
+    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Working directory." })),
+    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Timeout in ms (default 120000)." })),
+    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
+  }),
+  baseActionClass: "execute",
+  executionMode: "sequential",
+  prepareArguments: prepareVerifyArguments
+};
+
+// src/tools/safe-exec.ts
+init_esm_shims();
+var TRUNCATION_MARKER = "\n[output truncated]\n";
+function timeoutArg(args, fallback = SAFE_EXEC_DEFAULT_TIMEOUT_MS) {
+  return typeof args.timeout_ms === "number" && args.timeout_ms > 0 ? Math.floor(args.timeout_ms) : fallback;
+}
+function cwdArg(args) {
+  return typeof args.cwd === "string" && args.cwd.length > 0 ? args.cwd : void 0;
+}
+function maxOutputArg(args) {
+  return typeof args.max_output_bytes === "number" && args.max_output_bytes > 0 ? Math.floor(args.max_output_bytes) : SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES;
+}
+function resultDetails(result) {
+  return {
+    command: [result.file, ...result.args].join(" "),
+    cwd: result.cwd,
+    exitCode: result.exitCode,
+    durationMs: result.durationMs,
+    timedOut: result.timedOut,
+    outputCapped: result.outputCapped
+  };
+}
+async function runVectorTool(action, file, vectorArgs, args, options) {
+  const timeoutMs = timeoutArg(args);
+  const maxOutputBytes = maxOutputArg(args);
+  try {
+    const runOptions = { timeoutMs, maxOutputBytes };
+    const cwd = cwdArg(args);
+    if (cwd !== void 0) runOptions.cwd = cwd;
+    if (options?.signal !== void 0) runOptions.signal = options.signal;
+    const result = await runCommandVector(file, vectorArgs, runOptions);
+    const output = truncateUtf8(combineSafeOutput(result), maxOutputBytes, TRUNCATION_MARKER);
+    const details = resultDetails(result);
+    if (result.aborted) return { kind: "error", message: `${action}: aborted`, details };
+    if (result.timedOut) {
+      const status = `${action}: timed out after ${timeoutMs}ms`;
+      return { kind: "error", message: output.trim().length > 0 ? `${status}
+
+${output.trim()}` : status, details };
+    }
+    if (result.outputCapped)
+      return {
+        kind: "error",
+        message: output.trim().length > 0 ? `${action}: output exceeded ${maxOutputBytes} bytes
+
+${output.trim()}` : `${action}: output exceeded ${maxOutputBytes} bytes`,
+        details
+      };
+    if (result.exitCode !== 0) {
+      return {
+        kind: "error",
+        message: `${action}: exited with code ${result.exitCode ?? "?"}: ${output.trim()}`,
+        details
+      };
+    }
+    return { kind: "ok", output, details };
+  } catch (err) {
+    return { kind: "error", message: `${action}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var gitTool = {
+  name: ToolNames.Git,
+  description: "Read-only git inspection: op=status (short status), diff, or log (oneline).",
+  parameters: typebox_exports.Object({
+    op: StringEnum(["status", "diff", "log"], { description: "Inspection to run." }),
+    path: typebox_exports.Optional(typebox_exports.String({ description: "Limit diff/log to one path." })),
+    cached: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: staged changes (--cached)." })),
+    stat: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: summary only (--stat)." })),
+    name_only: typebox_exports.Optional(typebox_exports.Boolean({ description: "diff: file names only." })),
+    limit: typebox_exports.Optional(typebox_exports.Number({ description: "log: commits to show (default 20, max 200)." })),
+    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Working directory." })),
+    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Timeout in ms (default 120000)." })),
+    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel",
+  async run(args, options) {
+    const op = typeof args.op === "string" ? args.op : "";
+    const pathArg = typeof args.path === "string" && args.path.length > 0 ? args.path : null;
+    if (op === "status") {
+      return runVectorTool("git", "git", ["status", "--short", "--branch"], args, options);
+    }
+    if (op === "diff") {
+      const vector = ["diff"];
+      if (args.cached === true) vector.push("--cached");
+      if (args.stat === true) vector.push("--stat");
+      if (args.name_only === true) vector.push("--name-only");
+      if (pathArg) vector.push("--", pathArg);
+      return runVectorTool("git", "git", vector, args, options);
+    }
+    if (op === "log") {
+      const limit = typeof args.limit === "number" && args.limit > 0 ? Math.min(200, Math.floor(args.limit)) : 20;
+      const vector = ["log", "--oneline", "-n", String(limit)];
+      if (pathArg) vector.push("--", pathArg);
+      return runVectorTool("git", "git", vector, args, options);
+    }
+    return { kind: "error", message: `git: op must be status, diff, or log; got '${op}'` };
+  }
+};
+
+export {
+  timeoutArg,
+  maxOutputArg,
+  runVectorTool,
+  gitTool,
+  BROWSER_MODES,
+  prepareVerifyArguments,
+  verifyToolSurface
+};
+//# sourceMappingURL=chunk-ARBGF5F7.js.map

package/dist/{chunk-673JJUWJ.js → chunk-BMEMKKIT.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   DEFAULT_SETTINGS_YAML
-} from "./chunk-NMOX6HFD.js";
+} from "./chunk-ZDOOVTXZ.js";
 import {
   clioCacheDir,
   clioConfigDir,
@@ -143,4 +143,4 @@ function enforceHomePrefixGuard() {
 export {
   initializeClioHome
 };
-//# sourceMappingURL=chunk-673JJUWJ.js.map
+//# sourceMappingURL=chunk-BMEMKKIT.js.map

package/dist/chunk-CBCAPZAA.js

@@ -0,0 +1,229 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  SettingsValidationError,
+  applySettingsDelta,
+  settingsPath,
+  updateSavedSettingsDocument,
+  validateSettings
+} from "./chunk-A3CYT5EX.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/settings-layers.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var STRICT_USER_ISSUES = /* @__PURE__ */ Symbol("strict-user-issues");
+var CREDENTIAL_KEYS = /* @__PURE__ */ new Set(["auth", "apikey", "api_key", "token", "secret", "password"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((entry, index) => deepEquals(entry, b[index]));
+  }
+  if (!isRecord(a) || !isRecord(b)) return false;
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((key) => key in b && deepEquals(a[key], b[key]));
+}
+function readRawLayer(origin, path, issues) {
+  if (!existsSync(path)) return { origin, path, blob: void 0 };
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    issues.push({
+      origin,
+      path: "(root)",
+      message: `unreadable: ${err instanceof Error ? err.message : String(err)}`,
+      kind: "unreadable"
+    });
+    return { origin, path, blob: void 0 };
+  }
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(text);
+  } catch (err) {
+    issues.push({
+      origin,
+      path: "(root)",
+      message: `invalid YAML: ${err instanceof Error ? err.message : String(err)}`,
+      kind: "syntax"
+    });
+    return { origin, path, blob: void 0 };
+  }
+  if (parsed === null || parsed === void 0) return { origin, path, blob: {} };
+  if (!isRecord(parsed)) {
+    issues.push({ origin, path: "(root)", message: "settings file must be a mapping at the root" });
+    return { origin, path, blob: void 0 };
+  }
+  return { origin, path, blob: parsed };
+}
+function stripCredentials(value, origin, path, issues) {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => stripCredentials(item, origin, `${path}[${index}]`, issues));
+  }
+  if (!isRecord(value)) return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (CREDENTIAL_KEYS.has(key.toLowerCase())) {
+      issues.push({
+        origin,
+        path: path ? `${path}.${key}` : key,
+        message: "credentials are not allowed in project settings; key ignored"
+      });
+      continue;
+    }
+    out[key] = stripCredentials(child, origin, path ? `${path}.${key}` : key, issues);
+  }
+  return out;
+}
+function mergeLayersWithSources(layers) {
+  const merged = {};
+  const sources = {};
+  for (const layer of layers) {
+    if (layer.blob === void 0) continue;
+    mergeInto(merged, layer.blob, layer.origin, "", sources);
+  }
+  return { merged, sources };
+}
+function mergeInto(target, source, origin, prefix, sources) {
+  for (const [key, value] of Object.entries(source)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (isRecord(value)) {
+      const existing = target[key];
+      const nested = isRecord(existing) ? existing : {};
+      mergeInto(nested, value, origin, path, sources);
+      target[key] = nested;
+      sources[path] = origin;
+    } else {
+      target[key] = Array.isArray(value) ? [...value] : value;
+      sources[path] = origin;
+    }
+  }
+}
+function prepareProjectLayers(cwd, issues) {
+  const projectFile = join(cwd, ".clio-coder", "settings.yaml");
+  const localFile = join(cwd, ".clio-coder", "settings.local.yaml");
+  const projectRaw = readRawLayer("project", projectFile, issues);
+  const localRaw = readRawLayer("project.local", localFile, issues);
+  const project = {
+    ...projectRaw,
+    blob: projectRaw.blob === void 0 ? void 0 : stripCredentials(projectRaw.blob, "project", "", issues)
+  };
+  const local = {
+    ...localRaw,
+    blob: localRaw.blob === void 0 ? void 0 : stripCredentials(localRaw.blob, "project.local", "", issues)
+  };
+  return { projectFile, localFile, projectRaw, localRaw, project, local };
+}
+function validateLayerStack(user, prepared, issues) {
+  const { merged, sources } = mergeLayersWithSources([user, prepared.project, prepared.local]);
+  const validation = validateSettings(merged);
+  for (const issue of validation.issues) {
+    issues.push({ origin: settingsSourceFor(sources, issue.path), path: issue.path, message: issue.message });
+  }
+  return { settings: validation.settings, sources };
+}
+function readLayeredSettings(cwd, options = {}) {
+  const issues = [];
+  const userFile = options.userPath ?? settingsPath();
+  const user = readRawLayer("user", userFile, issues);
+  const prepared = prepareProjectLayers(cwd, issues);
+  const { settings, sources } = validateLayerStack(user, prepared, issues);
+  const strictUserIssues = user.blob === void 0 ? [] : validateSettings(user.blob).issues.map((issue) => ({
+    path: issue.path,
+    message: issue.message,
+    ...issue.kind ? { kind: issue.kind } : {}
+  }));
+  return {
+    settings,
+    sources,
+    issues,
+    layers: [
+      { origin: "built-in", path: "(defaults)", present: true },
+      { origin: "user", path: userFile, present: user.blob !== void 0 },
+      { origin: "project", path: prepared.projectFile, present: prepared.projectRaw.blob !== void 0 },
+      { origin: "project.local", path: prepared.localFile, present: prepared.localRaw.blob !== void 0 }
+    ],
+    [STRICT_USER_ISSUES]: strictUserIssues
+  };
+}
+function readStrictLayeredSettings(cwd, options = {}) {
+  const layered = readLayeredSettings(cwd, options);
+  const reportedUserIssues = layered.issues.filter((issue) => issue.origin === "user").map(({ path, message, kind }) => ({ path, message, ...kind ? { kind } : {} }));
+  const userIssues = [...reportedUserIssues, ...layered[STRICT_USER_ISSUES]].filter(
+    (issue, index, all) => all.findIndex(
+      (candidate) => candidate.path === issue.path && candidate.message === issue.message && candidate.kind === issue.kind
+    ) === index
+  );
+  if (userIssues.length > 0) throw new SettingsValidationError(userIssues);
+  return layered;
+}
+function updateLayeredSettings(cwd, mutate) {
+  let committed = null;
+  updateSavedSettingsDocument((saved) => {
+    const userValidation = validateSettings(saved);
+    if (userValidation.issues.length > 0) throw new SettingsValidationError(userValidation.issues);
+    const issues = [];
+    const prepared = prepareProjectLayers(cwd, issues);
+    const user = {
+      origin: "user",
+      path: settingsPath(),
+      blob: isRecord(saved) ? saved : {}
+    };
+    const before = validateLayerStack(user, prepared, issues).settings;
+    const candidate = structuredClone(before);
+    const next = mutate(candidate) ?? candidate;
+    const candidateValidation = validateSettings(JSON.parse(JSON.stringify(next)));
+    if (candidateValidation.issues.length > 0) throw new SettingsValidationError(candidateValidation.issues);
+    const nextSaved = applySettingsDelta(saved, before, candidateValidation.settings);
+    const finalIssues = [];
+    const final = validateLayerStack(
+      { origin: "user", path: settingsPath(), blob: isRecord(nextSaved) ? nextSaved : {} },
+      prepared,
+      finalIssues
+    ).settings;
+    if (!deepEquals(final, candidateValidation.settings)) {
+      throw new Error("a higher-precedence project setting prevents this settings update");
+    }
+    committed = final;
+    return nextSaved;
+  });
+  if (committed === null) throw new Error("layered settings update did not commit");
+  return committed;
+}
+function settingsSourceFor(sources, keyPath) {
+  let prefix = keyPath;
+  while (prefix.length > 0) {
+    const direct = sources[prefix];
+    if (direct) return direct;
+    const bracket = prefix.lastIndexOf("[");
+    if (bracket >= 0) {
+      const arrayKey = prefix.slice(0, bracket);
+      const hit = sources[arrayKey];
+      if (hit) return hit;
+    }
+    const dot = prefix.lastIndexOf(".");
+    if (dot < 0) break;
+    prefix = prefix.slice(0, dot);
+  }
+  return "built-in";
+}
+
+export {
+  readLayeredSettings,
+  readStrictLayeredSettings,
+  updateLayeredSettings,
+  settingsSourceFor
+};
+//# sourceMappingURL=chunk-CBCAPZAA.js.map