@evo-dev/core 0.0.1-alpha

package/dist/config/index.js

@@ -0,0 +1,601 @@
+// packages/core/src/config/errors.ts
+class EvoDevConfigError extends Error {
+  filePath;
+  constructor(message, filePath) {
+    super(filePath ? `${message}: ${filePath}` : message);
+    this.filePath = filePath;
+    this.name = "EvoDevConfigError";
+  }
+}
+function describeType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+}
+// packages/core/src/config/paths.ts
+function resolveEvoDevPaths(homeDir = getHomeDir()) {
+  const normalizedHome = stripTrailingSlash(homeDir);
+  const rootDir = `${normalizedHome}/.evodev`;
+  const stateDir = `${rootDir}/state`;
+  return {
+    homeDir: normalizedHome,
+    rootDir,
+    settingsPath: `${rootDir}/settings.json`,
+    registryPath: `${rootDir}/registry.json`,
+    stateDir,
+    installStatePath: `${stateDir}/install.json`,
+    syncStatePath: `${stateDir}/sync.json`
+  };
+}
+function getHomeDir() {
+  const home = process.env.HOME;
+  if (home === undefined || home.trim() === "") {
+    throw new Error("Cannot resolve home directory: HOME is not set");
+  }
+  return home;
+}
+function stripTrailingSlash(path) {
+  if (path === "/") {
+    return path;
+  }
+  return path.replace(/\/+$/, "");
+}
+// packages/core/src/config/registry.ts
+function createDefaultRegistry() {
+  return {
+    version: 1,
+    skills: {},
+    agents: {}
+  };
+}
+function parseRegistry(value) {
+  const root = expectRecord(value, "registry");
+  if (root.version !== 1) {
+    throw new EvoDevConfigError("Invalid registry.version; expected 1");
+  }
+  return {
+    version: 1,
+    skills: parseAssetMap(root.skills, "registry.skills"),
+    agents: parseAssetMap(root.agents, "registry.agents")
+  };
+}
+function parseAssetMap(value, path) {
+  const input = expectRecord(value, path);
+  const output = {};
+  for (const [assetId, asset] of Object.entries(input)) {
+    output[assetId] = parseRegisteredAsset(asset, `${path}.${assetId}`);
+  }
+  return output;
+}
+function parseRegisteredAsset(value, path) {
+  const input = expectRecord(value, path);
+  const source = input.source;
+  if (source !== "builtin" && source !== "user") {
+    throw new EvoDevConfigError(`Invalid ${path}.source; expected builtin or user`);
+  }
+  if (!Array.isArray(input.targets) || !input.targets.every((target) => typeof target === "string")) {
+    throw new EvoDevConfigError(`Invalid ${path}.targets; expected string array`);
+  }
+  return {
+    version: expectString(input.version, `${path}.version`),
+    source,
+    targets: [...input.targets]
+  };
+}
+function expectRecord(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected object, got ${describeType(value)}`);
+  }
+  return value;
+}
+function expectString(value, path) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected non-empty string`);
+  }
+  return value;
+}
+// packages/core/src/task/index.ts
+var FORBIDDEN_TASK_WRITE_SEGMENTS = new Set([".claude", ".codex"]);
+var FORBIDDEN_PROJECT_ASSET_SEGMENTS = new Set(["packages", "src"]);
+var FORBIDDEN_TASK_WRITE_FILES = new Set(["agents.md", "claude.md", "package.json", "readme.md"]);
+var FORBIDDEN_RAW_KEYS = new Set([
+  "rawoutput",
+  "raw_output",
+  "stdout",
+  "stderr",
+  "source",
+  "sourcecontent",
+  "source_content",
+  "sourcetext",
+  "source_text",
+  "prompt",
+  "prompttext",
+  "prompt_text",
+  "transcript",
+  "transcripttext",
+  "transcript_text",
+  "secret",
+  "secretvalue",
+  "secret_value"
+]);
+var ALLOWED_VERIFICATION_KEYS = new Set([
+  "acceptanceResults",
+  "antiCriteriaResults",
+  "commands",
+  "evidence",
+  "exitCode",
+  "id",
+  "status",
+  "summary",
+  "type"
+]);
+
+// packages/core/src/hooks/index.ts
+var CANONICAL_HOOK_EVENT_TYPES = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "UserPromptExpansion",
+  "PreToolUse",
+  "PermissionRequest",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "PostToolBatch",
+  "PermissionDenied",
+  "SubagentStart",
+  "Stop",
+  "StopFailure",
+  "TeammateIdle",
+  "SubagentStop",
+  "TaskCreated",
+  "TaskCompleted",
+  "PreCompact",
+  "PostCompact",
+  "SessionEnd",
+  "ConfigChange",
+  "CwdChanged",
+  "FileChanged",
+  "WorktreeCreate",
+  "WorktreeRemove"
+];
+var DEFAULT_EVENT_SETTINGS = {
+  SessionStart: false,
+  UserPromptSubmit: false,
+  UserPromptExpansion: false,
+  PreToolUse: false,
+  PermissionRequest: false,
+  PostToolUse: false,
+  PostToolUseFailure: false,
+  PostToolBatch: false,
+  PermissionDenied: false,
+  SubagentStart: false,
+  Stop: false,
+  StopFailure: false,
+  TeammateIdle: false,
+  SubagentStop: false,
+  TaskCreated: false,
+  TaskCompleted: false,
+  PreCompact: false,
+  PostCompact: false,
+  SessionEnd: false,
+  ConfigChange: false,
+  CwdChanged: false,
+  FileChanged: false,
+  WorktreeCreate: false,
+  WorktreeRemove: false
+};
+function createDefaultHookSettings() {
+  return {
+    enabled: false,
+    targets: {
+      claude: {
+        enabled: false,
+        events: { ...DEFAULT_EVENT_SETTINGS }
+      },
+      codex: {
+        enabled: false,
+        events: { ...DEFAULT_EVENT_SETTINGS }
+      }
+    },
+    observability: {
+      metadataOnly: true,
+      rawPayloadStorage: false,
+      appendEvents: false
+    },
+    learning: {
+      emitCandidates: false,
+      writeMemory: false
+    }
+  };
+}
+function parseHookSettings(value) {
+  const defaults = createDefaultHookSettings();
+  if (value === undefined || value === null)
+    return defaults;
+  if (!isRecord(value))
+    throw new Error("Invalid hooks settings; expected object.");
+  return {
+    enabled: optionalBoolean(value.enabled, defaults.enabled, "hooks.enabled"),
+    targets: {
+      claude: parseHookTargetSettings(value.targets, defaults.targets.claude, "claude"),
+      codex: parseHookTargetSettings(value.targets, defaults.targets.codex, "codex")
+    },
+    observability: {
+      metadataOnly: true,
+      rawPayloadStorage: false,
+      appendEvents: false
+    },
+    learning: {
+      emitCandidates: false,
+      writeMemory: false
+    }
+  };
+}
+function parseHookTargetSettings(value, defaults, target) {
+  const targets = isRecord(value) ? value : {};
+  const targetSettings = isRecord(targets[target]) ? targets[target] : {};
+  const events = isRecord(targetSettings.events) ? targetSettings.events : {};
+  const parsedEvents = { ...defaults.events };
+  for (const eventType of CANONICAL_HOOK_EVENT_TYPES) {
+    parsedEvents[eventType] = optionalBoolean(events[eventType], defaults.events[eventType], `hooks.targets.${target}.events.${eventType}`);
+  }
+  return {
+    enabled: optionalBoolean(targetSettings.enabled, defaults.enabled, `hooks.targets.${target}.enabled`),
+    events: parsedEvents
+  };
+}
+function optionalBoolean(value, fallback, path) {
+  if (value === undefined)
+    return fallback;
+  if (typeof value !== "boolean")
+    throw new Error(`Invalid ${path}; expected boolean.`);
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/core/src/config/settings.ts
+function createDefaultSettings(os = process.platform) {
+  return {
+    version: 1,
+    platform: {
+      os
+    },
+    plugins: {
+      claude: {
+        enabled: true,
+        autoSyncSkills: true,
+        autoSyncAgents: true
+      },
+      codex: {
+        enabled: false
+      }
+    },
+    assets: {
+      skills: {
+        enabled: true
+      },
+      agents: {
+        enabled: true
+      }
+    },
+    doctor: {
+      lastRunAt: null
+    },
+    hooks: createDefaultHookSettings()
+  };
+}
+function mergeSettings(existing, defaults = createDefaultSettings()) {
+  const merged = {
+    ...defaults,
+    ...existing,
+    platform: {
+      ...defaults.platform,
+      ...existing.platform
+    },
+    plugins: {
+      claude: {
+        ...defaults.plugins.claude,
+        ...existing.plugins?.claude
+      },
+      codex: {
+        ...defaults.plugins.codex,
+        ...existing.plugins?.codex
+      }
+    },
+    assets: {
+      skills: {
+        ...defaults.assets.skills,
+        ...existing.assets?.skills
+      },
+      agents: {
+        ...defaults.assets.agents,
+        ...existing.assets?.agents
+      }
+    },
+    doctor: {
+      ...defaults.doctor,
+      ...existing.doctor
+    },
+    hooks: existing.hooks ?? defaults.hooks
+  };
+  return parseSettings(merged);
+}
+function parseSettings(value) {
+  const root = expectRecord2(value, "settings");
+  const version = root.version;
+  if (version !== 1) {
+    throw new EvoDevConfigError("Invalid settings.version; expected 1");
+  }
+  const platform = expectRecord2(root.platform, "settings.platform");
+  const plugins = expectRecord2(root.plugins, "settings.plugins");
+  const assets = expectRecord2(root.assets, "settings.assets");
+  const doctor = expectRecord2(root.doctor, "settings.doctor");
+  const parsed = {
+    version: 1,
+    platform: {
+      os: expectString2(platform.os, "settings.platform.os")
+    },
+    plugins: {
+      claude: parsePluginSettings(plugins.claude, "settings.plugins.claude"),
+      codex: parsePluginSettings(plugins.codex, "settings.plugins.codex")
+    },
+    assets: {
+      skills: {
+        enabled: expectBoolean(expectRecord2(assets.skills, "settings.assets.skills").enabled, "settings.assets.skills.enabled")
+      },
+      agents: {
+        enabled: expectBoolean(expectRecord2(assets.agents, "settings.assets.agents").enabled, "settings.assets.agents.enabled")
+      }
+    },
+    doctor: {
+      lastRunAt: expectNullableString(doctor.lastRunAt, "settings.doctor.lastRunAt")
+    },
+    hooks: parseHookSettings(root.hooks)
+  };
+  return parsed;
+}
+function parsePluginSettings(value, path) {
+  const input = expectRecord2(value, path);
+  const parsed = {
+    enabled: expectBoolean(input.enabled, `${path}.enabled`)
+  };
+  if (input.autoSyncSkills !== undefined) {
+    parsed.autoSyncSkills = expectBoolean(input.autoSyncSkills, `${path}.autoSyncSkills`);
+  }
+  if (input.autoSyncAgents !== undefined) {
+    parsed.autoSyncAgents = expectBoolean(input.autoSyncAgents, `${path}.autoSyncAgents`);
+  }
+  return parsed;
+}
+function expectRecord2(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected object, got ${describeType(value)}`);
+  }
+  return value;
+}
+function expectString2(value, path) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected non-empty string`);
+  }
+  return value;
+}
+function expectNullableString(value, path) {
+  if (value === null || typeof value === "string") {
+    return value;
+  }
+  throw new EvoDevConfigError(`Invalid ${path}; expected string or null`);
+}
+function expectBoolean(value, path) {
+  if (typeof value !== "boolean") {
+    throw new EvoDevConfigError(`Invalid ${path}; expected boolean`);
+  }
+  return value;
+}
+// packages/core/src/config/state.ts
+function createDefaultInstallState() {
+  return {
+    version: 1,
+    initializedAt: null,
+    initializedBy: "evodev",
+    selectedPlugins: []
+  };
+}
+function createDefaultSyncState() {
+  return {
+    version: 1,
+    lastSyncAt: null,
+    targets: {}
+  };
+}
+function parseInstallState(value) {
+  const root = expectRecord3(value, "install state");
+  if (root.version !== 1) {
+    throw new EvoDevConfigError("Invalid install state.version; expected 1");
+  }
+  if (root.initializedBy !== "evodev") {
+    throw new EvoDevConfigError("Invalid install state.initializedBy; expected evodev");
+  }
+  if (!Array.isArray(root.selectedPlugins) || !root.selectedPlugins.every((plugin) => typeof plugin === "string")) {
+    throw new EvoDevConfigError("Invalid install state.selectedPlugins; expected string array");
+  }
+  return {
+    version: 1,
+    initializedAt: expectNullableString2(root.initializedAt, "install state.initializedAt"),
+    initializedBy: "evodev",
+    selectedPlugins: [...root.selectedPlugins]
+  };
+}
+function parseSyncState(value) {
+  const root = expectRecord3(value, "sync state");
+  if (root.version !== 1) {
+    throw new EvoDevConfigError("Invalid sync state.version; expected 1");
+  }
+  const targets = expectRecord3(root.targets, "sync state.targets");
+  const parsedTargets = {};
+  for (const [pluginId, state] of Object.entries(targets)) {
+    parsedTargets[pluginId] = parsePluginSyncState(state, `sync state.targets.${pluginId}`);
+  }
+  return {
+    version: 1,
+    lastSyncAt: expectNullableString2(root.lastSyncAt, "sync state.lastSyncAt"),
+    targets: parsedTargets
+  };
+}
+function parsePluginSyncState(value, path) {
+  const root = expectRecord3(value, path);
+  const status = root.status;
+  if (status !== "success" && status !== "partial" && status !== "failed" && status !== "never-run") {
+    throw new EvoDevConfigError(`Invalid ${path}.status; expected success, partial, failed, or never-run`);
+  }
+  return {
+    skills: expectNonNegativeInteger(root.skills, `${path}.skills`),
+    agents: expectNonNegativeInteger(root.agents, `${path}.agents`),
+    status
+  };
+}
+function expectRecord3(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected object, got ${describeType(value)}`);
+  }
+  return value;
+}
+function expectNullableString2(value, path) {
+  if (value === null || typeof value === "string") {
+    return value;
+  }
+  throw new EvoDevConfigError(`Invalid ${path}; expected string or null`);
+}
+function expectNonNegativeInteger(value, path) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new EvoDevConfigError(`Invalid ${path}; expected non-negative integer`);
+  }
+  return value;
+}
+// packages/core/src/config/store.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+function createCoreConfigStore(homeDir) {
+  const paths = resolveEvoDevPaths(homeDir);
+  return {
+    paths,
+    async ensureBaseDirs() {
+      await mkdir(paths.stateDir, { recursive: true });
+    },
+    async readSettings() {
+      return readJsonFile(paths.settingsPath, parseSettings);
+    },
+    async writeSettings(settings) {
+      await writeJsonFile(paths.settingsPath, parseSettings(settings));
+    },
+    async mergeAndWriteSettings(input) {
+      const current = await readJsonFileOrDefault(paths.settingsPath, parseSettings, createDefaultSettings());
+      const merged = mergeSettings(input, current);
+      await writeJsonFile(paths.settingsPath, merged);
+      return merged;
+    },
+    async readRegistry() {
+      return readJsonFile(paths.registryPath, parseRegistry);
+    },
+    async writeRegistry(registry) {
+      await writeJsonFile(paths.registryPath, parseRegistry(registry));
+    },
+    async readInstallState() {
+      return readJsonFile(paths.installStatePath, parseInstallState);
+    },
+    async writeInstallState(state) {
+      await writeJsonFile(paths.installStatePath, parseInstallState(state));
+    },
+    async readSyncState() {
+      return readJsonFile(paths.syncStatePath, parseSyncState);
+    },
+    async writeSyncState(state) {
+      await writeJsonFile(paths.syncStatePath, parseSyncState(state));
+    }
+  };
+}
+async function initializeCoreConfig(homeDir) {
+  const store = createCoreConfigStore(homeDir);
+  await store.ensureBaseDirs();
+  await writeIfMissing(store.paths.settingsPath, createDefaultSettings());
+  await writeIfMissing(store.paths.registryPath, createDefaultRegistry());
+  await writeIfMissing(store.paths.installStatePath, createDefaultInstallState());
+  await writeIfMissing(store.paths.syncStatePath, createDefaultSyncState());
+  return store;
+}
+async function readJsonFile(filePath, parse) {
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch (error) {
+    throw new EvoDevConfigError(`Cannot read config file (${describeFileError(error)})`, filePath);
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    throw new EvoDevConfigError(`Invalid JSON (${describeFileError(error)})`, filePath);
+  }
+  try {
+    return parse(json);
+  } catch (error) {
+    if (error instanceof EvoDevConfigError) {
+      throw new EvoDevConfigError(error.message, filePath);
+    }
+    throw error;
+  }
+}
+async function readJsonFileOrDefault(filePath, parse, fallback) {
+  try {
+    return await readJsonFile(filePath, parse);
+  } catch (error) {
+    if (error instanceof EvoDevConfigError && error.message.includes("ENOENT")) {
+      return fallback;
+    }
+    throw error;
+  }
+}
+async function writeIfMissing(filePath, value) {
+  try {
+    await readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      await writeJsonFile(filePath, value);
+      return;
+    }
+    throw new EvoDevConfigError(`Cannot inspect config file (${describeFileError(error)})`, filePath);
+  }
+}
+async function writeJsonFile(filePath, value) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function describeFileError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+export {
+  resolveEvoDevPaths,
+  parseSyncState,
+  parseSettings,
+  parseRegistry,
+  parseInstallState,
+  mergeSettings,
+  initializeCoreConfig,
+  createDefaultSyncState,
+  createDefaultSettings,
+  createDefaultRegistry,
+  createDefaultInstallState,
+  createCoreConfigStore,
+  EvoDevConfigError
+};