@evo-dev/core 0.0.1-alpha → 0.0.1-alpha.10

package/src/config/settings.ts

@@ -1,5 +1,12 @@
+import { readFile } from "node:fs/promises";
+import {
+  type SessionMemoryPolicySnapshot,
+  createDefaultSessionMemoryPolicy,
+  parseSessionMemoryPolicy,
+} from "../evolution/evidence/session-memory/index.ts";
 import { type HookSettings, createDefaultHookSettings, parseHookSettings } from "../hooks/index.ts";
 import { EvoDevConfigError, describeType } from "./errors.ts";
+import { resolveEvoDevPaths } from "./paths.ts";
 
 export interface PluginSettings {
   enabled: boolean;
@@ -7,6 +14,22 @@ export interface PluginSettings {
   autoSyncAgents?: boolean;
 }
 
+export interface MemorySettings {
+  autoAccept: boolean;
+  runtimeInjection: boolean;
+  staleReview: boolean;
+  lexicalIndex: boolean;
+  sessionMemory: SessionMemoryPolicySnapshot;
+}
+
+export interface EvolutionSettings {
+  automation: {
+    knowledge: boolean;
+    semanticKnowledge: boolean;
+    recommendations: boolean;
+  };
+}
+
 export interface EvoDevSettings {
   version: 1;
   platform: {
@@ -28,6 +51,9 @@ export interface EvoDevSettings {
     lastRunAt: string | null;
   };
   hooks: HookSettings;
+  teamRuntime: TeamRuntimeSettings;
+  memory: MemorySettings;
+  evolution: EvolutionSettings;
 }
 
 export type SettingsInput = Partial<{
@@ -43,8 +69,21 @@ export type SettingsInput = Partial<{
   }>;
   doctor: Partial<EvoDevSettings["doctor"]>;
   hooks: unknown;
+  teamRuntime: Partial<TeamRuntimeSettings>;
+  memory: Partial<MemorySettings>;
+  evolution: Partial<{
+    automation: Partial<EvolutionSettings["automation"]>;
+  }>;
 }>;
 
+export interface TeamRuntimeSettings {
+  defaultRuntime: "codex" | "claude";
+  defaultModel: string | null;
+  defaultThinkingLevel: string | null;
+  recordTranscript: boolean;
+  displayMode: "normal" | "development";
+}
+
 export function createDefaultSettings(os: string = process.platform): EvoDevSettings {
   return {
     version: 1,
@@ -73,6 +112,39 @@ export function createDefaultSettings(os: string = process.platform): EvoDevSett
       lastRunAt: null,
     },
     hooks: createDefaultHookSettings(),
+    teamRuntime: createDefaultTeamRuntimeSettings(),
+    memory: createDefaultMemorySettings(),
+    evolution: createDefaultEvolutionSettings(),
+  };
+}
+
+export function createDefaultTeamRuntimeSettings(): TeamRuntimeSettings {
+  return {
+    defaultRuntime: "codex",
+    defaultModel: null,
+    defaultThinkingLevel: null,
+    recordTranscript: false,
+    displayMode: "normal",
+  };
+}
+
+export function createDefaultMemorySettings(): MemorySettings {
+  return {
+    autoAccept: true,
+    runtimeInjection: true,
+    staleReview: true,
+    lexicalIndex: true,
+    sessionMemory: createDefaultSessionMemoryPolicy(),
+  };
+}
+
+export function createDefaultEvolutionSettings(): EvolutionSettings {
+  return {
+    automation: {
+      knowledge: true,
+      semanticKnowledge: false,
+      recommendations: false,
+    },
   };
 }
 
@@ -112,11 +184,37 @@ export function mergeSettings(
       ...existing.doctor,
     },
     hooks: existing.hooks ?? defaults.hooks,
+    teamRuntime: {
+      ...defaults.teamRuntime,
+      ...existing.teamRuntime,
+    },
+    memory: {
+      ...defaults.memory,
+      ...existing.memory,
+    },
+    evolution: {
+      ...defaults.evolution,
+      ...existing.evolution,
+      automation: {
+        ...defaults.evolution.automation,
+        ...existing.evolution?.automation,
+      },
+    },
   };
 
   return parseSettings(merged);
 }
 
+export async function readRuntimeInjectionSettings(homeDir?: string): Promise<MemorySettings> {
+  const paths = resolveEvoDevPaths(homeDir);
+  try {
+    return parseSettings(JSON.parse(await readFile(paths.settingsPath, "utf8"))).memory;
+  } catch (error) {
+    if (isNotFoundError(error)) return createDefaultMemorySettings();
+    throw error;
+  }
+}
+
 export function parseSettings(value: unknown): EvoDevSettings {
   const root = expectRecord(value, "settings");
   const version = root.version;
@@ -157,11 +255,104 @@ export function parseSettings(value: unknown): EvoDevSettings {
       lastRunAt: expectNullableString(doctor.lastRunAt, "settings.doctor.lastRunAt"),
     },
     hooks: parseHookSettings(root.hooks),
+    teamRuntime: parseTeamRuntimeSettings(
+      root.teamRuntime ?? createDefaultTeamRuntimeSettings(),
+      "settings.teamRuntime",
+    ),
+    memory: parseMemorySettings(root.memory ?? createDefaultMemorySettings(), "settings.memory"),
+    evolution: parseEvolutionSettings(
+      root.evolution ?? createDefaultEvolutionSettings(),
+      "settings.evolution",
+    ),
   };
 
   return parsed;
 }
 
+function parseEvolutionSettings(value: unknown, path: string): EvolutionSettings {
+  const input = expectRecord(value, path);
+  const defaults = createDefaultEvolutionSettings();
+  const automation = expectRecord(input.automation ?? defaults.automation, `${path}.automation`);
+  return {
+    automation: {
+      knowledge:
+        automation.knowledge === undefined
+          ? defaults.automation.knowledge
+          : expectBoolean(automation.knowledge, `${path}.automation.knowledge`),
+      semanticKnowledge:
+        automation.semanticKnowledge === undefined
+          ? defaults.automation.semanticKnowledge
+          : expectBoolean(automation.semanticKnowledge, `${path}.automation.semanticKnowledge`),
+      recommendations:
+        automation.recommendations === undefined
+          ? defaults.automation.recommendations
+          : expectBoolean(automation.recommendations, `${path}.automation.recommendations`),
+    },
+  };
+}
+
+function parseMemorySettings(value: unknown, path: string): MemorySettings {
+  const input = expectRecord(value, path);
+  const defaults = createDefaultMemorySettings();
+  return {
+    autoAccept:
+      input.autoAccept === undefined
+        ? defaults.autoAccept
+        : expectBoolean(input.autoAccept, `${path}.autoAccept`),
+    runtimeInjection:
+      input.runtimeInjection === undefined
+        ? defaults.runtimeInjection
+        : expectBoolean(input.runtimeInjection, `${path}.runtimeInjection`),
+    staleReview:
+      input.staleReview === undefined
+        ? defaults.staleReview
+        : expectBoolean(input.staleReview, `${path}.staleReview`),
+    lexicalIndex:
+      input.lexicalIndex === undefined
+        ? defaults.lexicalIndex
+        : expectBoolean(input.lexicalIndex, `${path}.lexicalIndex`),
+    sessionMemory: parseSessionMemoryPolicy(
+      isPlainRecord(input.sessionMemory) ? input.sessionMemory : defaults.sessionMemory,
+    ),
+  };
+}
+
+function parseTeamRuntimeSettings(value: unknown, path: string): TeamRuntimeSettings {
+  const input = expectRecord(value, path);
+  const defaults = createDefaultTeamRuntimeSettings();
+  const defaultRuntime = input.defaultRuntime ?? defaults.defaultRuntime;
+  if (defaultRuntime !== "codex" && defaultRuntime !== "claude") {
+    throw new EvoDevConfigError(`Invalid ${path}.defaultRuntime; expected codex or claude`);
+  }
+
+  return {
+    defaultRuntime,
+    defaultModel:
+      input.defaultModel === undefined
+        ? defaults.defaultModel
+        : expectNullableString(input.defaultModel, `${path}.defaultModel`),
+    defaultThinkingLevel:
+      input.defaultThinkingLevel === undefined
+        ? defaults.defaultThinkingLevel
+        : expectNullableString(input.defaultThinkingLevel, `${path}.defaultThinkingLevel`),
+    recordTranscript:
+      input.recordTranscript === undefined
+        ? defaults.recordTranscript
+        : expectBoolean(input.recordTranscript, `${path}.recordTranscript`),
+    displayMode: parseTeamRuntimeDisplayMode(input.displayMode, defaults.displayMode, path),
+  };
+}
+
+function parseTeamRuntimeDisplayMode(
+  value: unknown,
+  fallback: TeamRuntimeSettings["displayMode"],
+  path: string,
+): TeamRuntimeSettings["displayMode"] {
+  if (value === undefined) return fallback;
+  if (value === "normal" || value === "development") return value;
+  throw new EvoDevConfigError(`Invalid ${path}.displayMode; expected normal or development`);
+}
+
 function parsePluginSettings(value: unknown, path: string): PluginSettings {
   const input = expectRecord(value, path);
   const parsed: PluginSettings = {
@@ -187,6 +378,16 @@ function expectRecord(value: unknown, path: string): Record<string, unknown> {
   return value as Record<string, unknown>;
 }
 
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return (
+    error instanceof Error && "code" in error && (error as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
 function expectString(value: unknown, path: string): string {
   if (typeof value !== "string" || value.length === 0) {
     throw new EvoDevConfigError(`Invalid ${path}; expected non-empty string`);

package/src/config/store.ts

@@ -1,5 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+import { ensureOkfKnowledgeBase } from "../evolution/knowledge/index.ts";
 import { EvoDevConfigError } from "./errors.ts";
 import { type EvoDevPaths, resolveEvoDevPaths } from "./paths.ts";
 import { type EvoDevRegistry, createDefaultRegistry, parseRegistry } from "./registry.ts";
@@ -22,6 +23,7 @@ import {
 export interface CoreConfigStore {
   readonly paths: EvoDevPaths;
   ensureBaseDirs(): Promise<void>;
+  ensureKnowledgeBase(): Promise<void>;
   readSettings(): Promise<EvoDevSettings>;
   writeSettings(settings: EvoDevSettings): Promise<void>;
   mergeAndWriteSettings(input: SettingsInput): Promise<EvoDevSettings>;
@@ -40,6 +42,15 @@ export function createCoreConfigStore(homeDir?: string): CoreConfigStore {
     paths,
     async ensureBaseDirs() {
       await mkdir(paths.stateDir, { recursive: true });
+      await mkdir(paths.logsDir, { recursive: true });
+      await mkdir(paths.knowledgeDir, { recursive: true });
+      await mkdir(paths.evosCasesDir, { recursive: true });
+      await mkdir(paths.roleAgentsDir, { recursive: true });
+      await mkdir(paths.teamsDir, { recursive: true });
+      await mkdir(paths.runsDir, { recursive: true });
+    },
+    async ensureKnowledgeBase() {
+      await ensureKnowledgeBaseFiles(paths);
     },
     async readSettings() {
       return readJsonFile(paths.settingsPath, parseSettings);
@@ -81,6 +92,7 @@ export function createCoreConfigStore(homeDir?: string): CoreConfigStore {
 export async function initializeCoreConfig(homeDir?: string): Promise<CoreConfigStore> {
   const store = createCoreConfigStore(homeDir);
   await store.ensureBaseDirs();
+  await store.ensureKnowledgeBase();
   await writeIfMissing(store.paths.settingsPath, createDefaultSettings());
   await writeIfMissing(store.paths.registryPath, createDefaultRegistry());
   await writeIfMissing(store.paths.installStatePath, createDefaultInstallState());
@@ -88,6 +100,88 @@ export async function initializeCoreConfig(homeDir?: string): Promise<CoreConfig
   return store;
 }
 
+export async function ensureKnowledgeBaseFiles(paths: EvoDevPaths): Promise<void> {
+  await mkdir(paths.knowledgeDir, { recursive: true });
+  await mkdir(paths.evosCasesDir, { recursive: true });
+  await ensureOkfKnowledgeBase(paths.homeDir);
+  await writeTextIfMissing(
+    `${paths.knowledgeDir}/README.md`,
+    [
+      "# EvoDev Knowledge",
+      "",
+      "Local-private knowledge base for user-accepted facts, decisions, architecture notes, and reusable domain context.",
+      "",
+      "EvoDev must not populate this directory from source code, prompts, command output, logs, or transcripts without an explicit consent flow.",
+      "",
+    ].join("\n"),
+  );
+  await writeIndexIfMissingOrMigrate(paths.knowledgeIndexPath, "knowledge-index", {
+    version: 1,
+    kind: "knowledge-index",
+    roleTags: [],
+    entries: [],
+  });
+  await writeTextIfMissing(
+    `${paths.evosDir}/README.md`,
+    [
+      "# EvoDev Evos",
+      "",
+      "Local-private evolution case library for reviewed improvement cases and reusable process changes.",
+      "",
+      "Cases start empty. Future automation may propose candidates, but accepted evos require explicit review before they can influence workflows or routing.",
+      "",
+    ].join("\n"),
+  );
+  await writeTextIfMissing(
+    `${paths.evosCasesDir}/README.md`,
+    [
+      "# Evolution Cases",
+      "",
+      "Store one reviewed evolution case per file. Do not store raw prompts, source dumps, secrets, transcripts, or raw command output here.",
+      "",
+    ].join("\n"),
+  );
+  await writeIndexIfMissingOrMigrate(paths.evosIndexPath, "evos-index", {
+    version: 1,
+    kind: "evos-index",
+    roleTags: [],
+    cases: [],
+  });
+  await writeTextIfMissing(
+    `${paths.roleAgentsDir}/README.md`,
+    [
+      "# Role Agents",
+      "",
+      "Local-private role agent registry for EvoDev-managed agent roles and user-reviewed role extensions.",
+      "",
+      "Repository-specific role agents should be proposed first and written into a user repository only after explicit project opt-in.",
+      "",
+    ].join("\n"),
+  );
+  await writeIndexIfMissingOrMigrate(paths.roleAgentsIndexPath, "role-agent-index", {
+    version: 1,
+    kind: "role-agent-index",
+    roles: [],
+    projectExtensions: [],
+  });
+  await writeTextIfMissing(
+    `${paths.teamsDir}/README.md`,
+    [
+      "# Agent Teams",
+      "",
+      "Local-private EvoHub team registry for reviewed role-agent team definitions.",
+      "",
+      "Teams may reference role agents and role-tagged knowledge, but they must not contain raw source, prompts, transcripts, secrets, or raw command output.",
+      "",
+    ].join("\n"),
+  );
+  await writeIndexIfMissingOrMigrate(paths.teamsIndexPath, "agent-team-index", {
+    version: 1,
+    kind: "agent-team-index",
+    teams: [],
+  });
+}
+
 async function readJsonFile<T>(filePath: string, parse: (value: unknown) => T): Promise<T> {
   let raw: string;
 
@@ -148,6 +242,60 @@ async function writeIfMissing(filePath: string, value: unknown): Promise<void> {
   }
 }
 
+async function writeIndexIfMissingOrMigrate(
+  filePath: string,
+  kind: string,
+  defaults: Record<string, unknown>,
+): Promise<void> {
+  let raw: string;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      await writeJsonFile(filePath, defaults);
+      return;
+    }
+
+    throw new EvoDevConfigError(
+      `Cannot inspect config file (${describeFileError(error)})`,
+      filePath,
+    );
+  }
+
+  let existing: unknown;
+  try {
+    existing = JSON.parse(raw);
+  } catch (error) {
+    throw new EvoDevConfigError(
+      `Invalid bootstrap index JSON (${describeFileError(error)})`,
+      filePath,
+    );
+  }
+
+  if (!isRecord(existing) || existing.kind !== kind) return;
+
+  const migrated = { ...defaults, ...existing };
+  if (Object.keys(defaults).every((key) => key in existing)) return;
+  await writeJsonFile(filePath, migrated);
+}
+
+async function writeTextIfMissing(filePath: string, value: string): Promise<void> {
+  try {
+    await readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, value, "utf8");
+      return;
+    }
+
+    throw new EvoDevConfigError(
+      `Cannot inspect config file (${describeFileError(error)})`,
+      filePath,
+    );
+  }
+}
+
 async function writeJsonFile(filePath: string, value: unknown): Promise<void> {
   await mkdir(dirname(filePath), { recursive: true });
   await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
@@ -164,3 +312,7 @@ function describeFileError(error: unknown): string {
 function isNodeError(error: unknown): error is NodeJS.ErrnoException {
   return error instanceof Error && "code" in error;
 }
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}