@iowarp/clio-coder 0.3.0

package/dist/chunk-AMFR5YA3.js

@@ -0,0 +1,541 @@
+import {
+  readSettings,
+  settingsPath,
+  updateSettings
+} from "./chunk-JWHCJDCI.js";
+import {
+  DEFAULT_SETTINGS
+} from "./chunk-UHTSULZS.js";
+import {
+  safeResourceBackupPath,
+  safeResourceWrite
+} from "./chunk-VPAWTYLY.js";
+import {
+  clioConfigDir,
+  resolveClioDirs
+} from "./chunk-X3NE4WVW.js";
+import {
+  readClioVersion
+} from "./chunk-DXQNI4PC.js";
+
+// src/domains/share/archive.ts
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var PROJECT_CONTEXT_FILES = ["CLIO-CODER.md", "AGENTS.md", "CODEX.md", "GEMINI.md", "CLAUDE.md"];
+var SETTINGS_FRAGMENT_PATH = "settings.fragment.yaml";
+function sha256(buffer) {
+  return createHash("sha256").update(buffer).digest("hex");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isErrorWithCode(value) {
+  return value instanceof Error && "code" in value;
+}
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((entry) => stableJson(entry)).join(",")}]`;
+  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+}
+function readDirRecursive(root) {
+  if (!existsSync(root)) return [];
+  const out = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.name === ".DS_Store") continue;
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(root, fullPath).split(path.sep).join("/");
+      const stat = statSync(fullPath);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+      if (entry.isFile()) out.push({ fullPath, relativePath, stat });
+    }
+  };
+  try {
+    if (statSync(root).isDirectory()) walk(root);
+  } catch {
+    return [];
+  }
+  return out;
+}
+function addBufferFile(files, input) {
+  files.push({
+    type: input.type,
+    scope: input.scope,
+    archivePath: input.archivePath.split(path.sep).join("/"),
+    relativePath: input.relativePath.split(path.sep).join("/"),
+    sha256: sha256(input.buffer),
+    size: input.buffer.byteLength,
+    encoding: "base64",
+    data: input.buffer.toString("base64")
+  });
+}
+function addTree(files, type, scope, root, archivePrefix, filter) {
+  for (const entry of readDirRecursive(root)) {
+    if (filter && !filter(entry.relativePath)) continue;
+    const buffer = readFileSync(entry.fullPath);
+    addBufferFile(files, {
+      type,
+      scope,
+      archivePath: `${archivePrefix}/${entry.relativePath}`,
+      relativePath: entry.relativePath,
+      buffer
+    });
+  }
+}
+function settingsFragment(settings) {
+  return {
+    autonomy: settings.autonomy,
+    scope: settings.scope,
+    budget: settings.budget,
+    theme: settings.theme,
+    terminal: settings.terminal,
+    keybindings: settings.keybindings,
+    compaction: settings.compaction,
+    retry: settings.retry
+  };
+}
+function requestedScopes(scope) {
+  if (scope === "both") return ["project", "user"];
+  return [scope ?? "project"];
+}
+function defaultedIncludes(options) {
+  const hasExplicitInclude = options.includeContext !== void 0 || options.includePrompts !== void 0 || options.includeSkills !== void 0 || options.includeSettings !== void 0 || options.includeExtensions !== void 0;
+  return {
+    includeContext: hasExplicitInclude ? options.includeContext === true : true,
+    includePrompts: hasExplicitInclude ? options.includePrompts === true : true,
+    includeSkills: hasExplicitInclude ? options.includeSkills === true : true,
+    includeSettings: hasExplicitInclude ? options.includeSettings === true : true,
+    includeExtensions: hasExplicitInclude ? options.includeExtensions === true : true
+  };
+}
+function createShareArchive(options = {}) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const files = [];
+  const includes = defaultedIncludes(options);
+  const scopes = requestedScopes(options.scope);
+  if (includes.includeContext && scopes.includes("project")) {
+    for (const name of PROJECT_CONTEXT_FILES) {
+      const full = path.join(cwd, name);
+      try {
+        if (!statSync(full).isFile()) continue;
+        addBufferFile(files, {
+          type: "project-context",
+          scope: "project",
+          archivePath: `project/${name}`,
+          relativePath: name,
+          buffer: readFileSync(full)
+        });
+      } catch {
+      }
+    }
+  }
+  if (includes.includePrompts) {
+    for (const scope of scopes) {
+      const root = scope === "user" ? path.join(clioConfigDir(), "prompts") : path.join(cwd, ".clio-coder", "prompts");
+      addTree(files, "prompt", scope, root, `${scope}/prompts`);
+    }
+  }
+  if (includes.includeSkills) {
+    for (const scope of scopes) {
+      const root = scope === "user" ? path.join(clioConfigDir(), "skills") : path.join(cwd, ".clio-coder", "skills");
+      addTree(files, "skill", scope, root, `${scope}/skills`);
+    }
+  }
+  if (includes.includeExtensions) {
+    for (const scope of scopes) {
+      const root = scope === "user" ? path.join(clioConfigDir(), "extensions") : path.join(cwd, ".clio-coder", "extensions");
+      addTree(files, "extension", scope, root, `${scope}/extensions`, (rel) => path.basename(rel) !== "state.json");
+    }
+  }
+  if (includes.includeSettings) {
+    const buffer = Buffer.from(stringifyYaml(settingsFragment(readSettings())), "utf8");
+    addBufferFile(files, {
+      type: "settings",
+      scope: "user",
+      archivePath: SETTINGS_FRAGMENT_PATH,
+      relativePath: SETTINGS_FRAGMENT_PATH,
+      buffer
+    });
+  }
+  const manifestFiles = files.map(({ data: _data, encoding: _encoding, ...entry }) => entry);
+  return {
+    kind: "clio-share-archive",
+    formatVersion: 1,
+    manifest: {
+      format: "clio.share.v1",
+      clioVersion: readClioVersion(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files: manifestFiles
+    },
+    files: files.sort((a, b) => a.archivePath.localeCompare(b.archivePath))
+  };
+}
+function writeShareArchive(outPath, options = {}) {
+  const archive = createShareArchive(options);
+  safeResourceWrite(path.resolve(outPath), `${stableJson(archive)}
+`, { encoding: "utf8" });
+  return archive;
+}
+function decodeArchiveFile(entry) {
+  return Buffer.from(entry.data, entry.encoding);
+}
+function parseArchive(raw) {
+  if (!isRecord(raw) || raw.kind !== "clio-share-archive" || raw.formatVersion !== 1 || !isRecord(raw.manifest)) {
+    throw new Error("not a Clio share archive v1");
+  }
+  if (raw.manifest.format !== "clio.share.v1" || !Array.isArray(raw.files)) {
+    throw new Error("share archive manifest is malformed");
+  }
+  const archive = raw;
+  for (const file of archive.files) {
+    if (!isRecord(file) || typeof file.archivePath !== "string" || typeof file.relativePath !== "string" || typeof file.sha256 !== "string" || file.encoding !== "base64" || typeof file.data !== "string") {
+      throw new Error("share archive file entry is malformed");
+    }
+    const actual = sha256(decodeArchiveFile(file));
+    if (actual !== file.sha256) throw new Error(`share archive checksum mismatch for ${file.archivePath}`);
+  }
+  return archive;
+}
+function readShareArchive(filePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(filePath, "utf8"));
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`share archive could not be read: ${reason}`);
+  }
+  return parseArchive(parsed);
+}
+function configDirPath() {
+  return path.resolve(resolveClioDirs().config);
+}
+function settingsFilePath() {
+  return path.join(configDirPath(), "settings.yaml");
+}
+function relativePathSegments(relativePath) {
+  if (relativePath.length === 0 || relativePath.includes("\0")) return null;
+  if (path.isAbsolute(relativePath) || path.win32.isAbsolute(relativePath)) return null;
+  const segments = relativePath.replace(/\\/g, "/").split("/");
+  if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) return null;
+  return segments;
+}
+function targetRootForFile(entry, options) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const config = configDirPath();
+  const scope = options.scope ?? entry.scope;
+  switch (entry.type) {
+    case "project-context":
+      return { root: cwd, containmentRoot: cwd, scope: "project" };
+    case "prompt":
+      return scope === "user" ? { root: path.join(config, "prompts"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "prompts"), containmentRoot: cwd, scope };
+    case "skill":
+      return scope === "user" ? { root: path.join(config, "skills"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "skills"), containmentRoot: cwd, scope };
+    case "extension":
+      return scope === "user" ? { root: path.join(config, "extensions"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "extensions"), containmentRoot: cwd, scope };
+    case "settings":
+      return { root: config, containmentRoot: config, scope };
+  }
+}
+function isInsideOrEqual(candidate, root) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function lstatExists(candidate) {
+  try {
+    lstatSync(candidate);
+    return true;
+  } catch (err) {
+    if (isErrorWithCode(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) return false;
+    throw err;
+  }
+}
+function nearestExistingPath(candidate) {
+  let current = path.resolve(candidate);
+  while (!lstatExists(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+  return current;
+}
+function pathDiagnostic(entry) {
+  return `${entry.archivePath} -> ${entry.relativePath}`;
+}
+function validateRealPathContainment(entry, target, containmentRoot) {
+  const rootAnchor = nearestExistingPath(containmentRoot);
+  const targetAnchor = nearestExistingPath(lstatExists(target) ? target : path.dirname(target));
+  if (!rootAnchor || !targetAnchor) {
+    return {
+      type: "error",
+      message: `share archive target could not be resolved safely: ${pathDiagnostic(entry)}`,
+      path: entry.relativePath
+    };
+  }
+  let realRoot;
+  let realTarget;
+  try {
+    realRoot = realpathSync(rootAnchor);
+    realTarget = realpathSync(targetAnchor);
+  } catch {
+    return {
+      type: "error",
+      message: `share archive target could not be resolved safely: ${pathDiagnostic(entry)}`,
+      path: entry.relativePath
+    };
+  }
+  if (!isInsideOrEqual(realTarget, realRoot)) {
+    return {
+      type: "error",
+      message: `share archive target escapes import root: ${pathDiagnostic(entry)}`,
+      path: entry.relativePath
+    };
+  }
+  return null;
+}
+function resolveImportTarget(entry, options) {
+  const segments = relativePathSegments(entry.relativePath);
+  if (!segments) {
+    return {
+      type: "error",
+      message: `share archive relativePath is not safe: ${pathDiagnostic(entry)}`,
+      path: entry.relativePath
+    };
+  }
+  const targetRoot = targetRootForFile(entry, options);
+  const target = entry.type === "settings" ? settingsFilePath() : path.resolve(targetRoot.root, ...segments);
+  if (!isInsideOrEqual(target, targetRoot.root)) {
+    return {
+      type: "error",
+      message: `share archive target escapes import root: ${pathDiagnostic(entry)}`,
+      path: entry.relativePath
+    };
+  }
+  const realPathDiagnostic = validateRealPathContainment(entry, target, targetRoot.containmentRoot);
+  if (realPathDiagnostic) return realPathDiagnostic;
+  return { entry, target, scope: targetRoot.scope, buffer: decodeArchiveFile(entry) };
+}
+function preflightImportTargets(archive, options) {
+  const targets = [];
+  const diagnostics = [];
+  for (const entry of archive.files) {
+    const resolved = resolveImportTarget(entry, options);
+    if ("type" in resolved) {
+      diagnostics.push(resolved);
+      continue;
+    }
+    targets.push(resolved);
+  }
+  if (diagnostics.length > 0) return { targets: [], diagnostics };
+  return { targets, diagnostics };
+}
+function versionDiagnostics(archive) {
+  const current = readClioVersion();
+  const [curMajor, curMinor] = current.split(".");
+  const [arcMajor, arcMinor] = archive.manifest.clioVersion.split(".");
+  if (curMajor !== arcMajor || curMinor !== arcMinor) {
+    return [
+      {
+        type: "warning",
+        message: `archive was created by Clio ${archive.manifest.clioVersion}; current Clio is ${current}`
+      }
+    ];
+  }
+  return [];
+}
+function settingsPlan(buffer, options) {
+  const parsed = parseYaml(buffer.toString("utf8"));
+  if (!isRecord(parsed)) return [{ type: "error", message: "settings fragment must be a YAML object" }];
+  const settingsTarget = settingsFilePath();
+  const current = settingsFragment(existsSync(settingsTarget) ? readSettings() : DEFAULT_SETTINGS);
+  const diagnostics = [];
+  for (const [key, value] of Object.entries(parsed)) {
+    if (key in current && JSON.stringify(current[key]) !== JSON.stringify(value)) {
+      diagnostics.push({
+        type: "conflict",
+        message: `settings fragment changes ${key}`,
+        path: settingsTarget
+      });
+    }
+  }
+  return options.force ? diagnostics.filter((diag) => diag.type !== "conflict") : diagnostics;
+}
+function prepareShareImport(filePath, options = {}) {
+  let archive;
+  try {
+    archive = readShareArchive(filePath);
+  } catch (err) {
+    return {
+      archive: null,
+      actions: [],
+      diagnostics: [{ type: "error", message: err instanceof Error ? err.message : String(err), path: filePath }],
+      targets: []
+    };
+  }
+  const diagnostics = [...versionDiagnostics(archive)];
+  const actions = [];
+  const preflight = preflightImportTargets(archive, options);
+  if (preflight.diagnostics.length > 0) {
+    return { archive, actions: [], diagnostics: [...diagnostics, ...preflight.diagnostics], targets: [] };
+  }
+  for (const targetInfo of preflight.targets) {
+    const { entry, target, scope, buffer } = targetInfo;
+    if (entry.type === "settings") {
+      diagnostics.push(...settingsPlan(buffer, options));
+      actions.push({ action: "settings", type: entry.type, scope, path: target });
+      continue;
+    }
+    if (existsSync(target)) {
+      const same = sha256(readFileSync(target)) === entry.sha256;
+      if (same) {
+        actions.push({ action: "skip", type: entry.type, scope, path: target });
+      } else if (options.force) {
+        actions.push({ action: "overwrite", type: entry.type, scope, path: target });
+      } else {
+        diagnostics.push({ type: "conflict", message: `destination already exists with different content`, path: target });
+        actions.push({ action: "skip", type: entry.type, scope, path: target });
+      }
+      continue;
+    }
+    actions.push({ action: "write", type: entry.type, scope, path: target });
+  }
+  return { archive, actions, diagnostics, targets: preflight.targets };
+}
+function publicImportPlan(prepared, recovery) {
+  return {
+    archive: prepared.archive,
+    actions: prepared.actions,
+    diagnostics: prepared.diagnostics,
+    ...recovery ? { recovery } : {}
+  };
+}
+function planShareImport(filePath, options = {}) {
+  return publicImportPlan(prepareShareImport(filePath, options));
+}
+function mergeSettingsFragment(buffer) {
+  const parsed = parseYaml(buffer.toString("utf8"));
+  if (!isRecord(parsed)) throw new Error("settings fragment must be a YAML object");
+  updateSettings((settings) => {
+    const next = settings;
+    for (const key of [
+      "autonomy",
+      "scope",
+      "budget",
+      "theme",
+      "terminal",
+      "keybindings",
+      "compaction",
+      "retry"
+    ]) {
+      if (key in parsed) next[key] = parsed[key];
+    }
+  });
+  return settingsPath();
+}
+function importShareArchive(filePath, options = {}) {
+  const prepared = prepareShareImport(filePath, options);
+  const plan = publicImportPlan(prepared);
+  if (!prepared.archive || options.dryRun) return plan;
+  if (prepared.diagnostics.some((diag) => diag.type === "error" || diag.type === "conflict")) return plan;
+  const written = [];
+  const backups = [];
+  const rememberWrite = (result) => {
+    if (!written.includes(result.path)) written.push(result.path);
+    if (result.backupPath && !backups.includes(result.backupPath)) backups.push(result.backupPath);
+  };
+  let failed;
+  try {
+    for (let index = 0; index < prepared.targets.length; index += 1) {
+      const targetInfo = prepared.targets[index];
+      const action = prepared.actions[index];
+      if (!targetInfo || !action || action.action === "skip") continue;
+      failed = targetInfo.target;
+      if (targetInfo.entry.type === "settings") {
+        const path2 = mergeSettingsFragment(targetInfo.buffer);
+        if (!written.includes(path2)) written.push(path2);
+        failed = void 0;
+        continue;
+      }
+      rememberWrite(
+        safeResourceWrite(targetInfo.target, targetInfo.buffer, {
+          backup: action.action === "overwrite"
+        })
+      );
+      failed = void 0;
+    }
+    return plan;
+  } catch (err) {
+    if (failed) {
+      const expectedBackup = safeResourceBackupPath(failed);
+      if (existsSync(expectedBackup) && !backups.includes(expectedBackup)) backups.push(expectedBackup);
+    }
+    const reason = err instanceof Error ? err.message : String(err);
+    const recovery = {
+      written,
+      backups,
+      ...failed ? { failed } : {}
+    };
+    return publicImportPlan(
+      {
+        ...prepared,
+        diagnostics: [
+          ...prepared.diagnostics,
+          {
+            type: "error",
+            message: `share import failed while writing${failed ? ` ${failed}` : ""}: ${reason}`,
+            ...failed ? { path: failed } : {}
+          }
+        ]
+      },
+      recovery
+    );
+  }
+}
+
+// src/domains/share/extension.ts
+function createShareBundle(_context) {
+  const extension = {
+    start() {
+      return void 0;
+    }
+  };
+  const contract = {
+    createArchive(options) {
+      return createShareArchive(options);
+    },
+    writeArchive(outPath, options) {
+      return writeShareArchive(outPath, options);
+    },
+    planImport(filePath, options) {
+      return planShareImport(filePath, options);
+    },
+    importArchive(filePath, options) {
+      return importShareArchive(filePath, options);
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/share/manifest.ts
+var ShareManifest = {
+  name: "share",
+  dependsOn: ["config", "extensions", "resources"]
+};
+
+// src/domains/share/index.ts
+var ShareDomainModule = {
+  manifest: ShareManifest,
+  createExtension: createShareBundle
+};
+
+export {
+  writeShareArchive,
+  planShareImport,
+  importShareArchive,
+  ShareDomainModule
+};
+//# sourceMappingURL=chunk-AMFR5YA3.js.map