@evo-dev/core 0.0.1-alpha.3 → 0.0.1-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evo-dev/core",
-  "version": "0.0.1-alpha.3",
+  "version": "0.0.1-alpha.4",
   "type": "module",
   "repository": {
     "type": "git",

package/src/agents/index.ts

@@ -3,7 +3,7 @@ import {
   type ScopedKnowledgeContextPack,
   createScopedKnowledgeContextPack,
   formatScopedKnowledgePromptBlock,
-} from "../knowledge/index.ts";
+} from "../evolution/knowledge/index.ts";
 import type { TaskContract, TaskExecutionMode } from "../task/index.ts";
 
 export type AgentPersistence = "named" | "dynamic";

package/src/code-agent-traces/index.ts

@@ -1,8 +1,8 @@
-import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, relative } from "node:path";
 import { resolveEvoDevPaths } from "../config/paths.ts";
 import { resolveTraceSessionKey, resolveTraceTeamContext } from "../runtime-logs/index.ts";
+import { normalizeTimestamp, sha256Short } from "../utils/index.ts";
 
 export type CodeAgentTraceTarget = "claude" | "codex";
 export type CodeAgentTraceRefSource =
@@ -440,7 +440,7 @@ function hasRawTraversalSegment(path: string): boolean {
 
 function hashOptionalIdentifier(value: string | null): string | null {
   if (value === null || value.trim() === "") return null;
-  return `sha256-${createHash("sha256").update(value).digest("hex").slice(0, 16)}`;
+  return `sha256-${sha256Short(value)}`;
 }
 
 function sanitizeHashMetadata(value: string | null): string | null {
@@ -454,8 +454,7 @@ function sanitizePersistentIdentifier(value: string, prefix: string): string {
   if (!SENSITIVE_IDENTIFIER_PATTERN.test(value) && !SENSITIVE_IDENTIFIER_PATTERN.test(pathSafe)) {
     return pathSafe;
   }
-  const hash = createHash("sha256").update(value).digest("hex").slice(0, 16);
-  return `${prefix}-${hash}`;
+  return `${prefix}-${sha256Short(value)}`;
 }
 
 function sanitizeNotes(notes: string[]): string[] {
@@ -471,12 +470,6 @@ function sanitizeNote(note: string): string {
   return truncated;
 }
 
-function normalizeTimestamp(value?: Date | string): string {
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string" && value.trim() !== "") return new Date(value).toISOString();
-  return new Date().toISOString();
-}
-
 function optionalString(value: unknown): string | null {
   return typeof value === "string" && value.trim() !== "" ? value : null;
 }

package/src/config/settings.ts

@@ -1,4 +1,9 @@
 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";
@@ -14,6 +19,7 @@ export interface MemorySettings {
   runtimeInjection: boolean;
   staleReview: boolean;
   lexicalIndex: boolean;
+  sessionMemory: SessionMemoryPolicySnapshot;
 }
 
 export interface EvoDevSettings {
@@ -115,6 +121,7 @@ export function createDefaultMemorySettings(): MemorySettings {
     runtimeInjection: true,
     staleReview: true,
     lexicalIndex: true,
+    sessionMemory: createDefaultSessionMemoryPolicy(),
   };
 }
 
@@ -247,6 +254,9 @@ function parseMemorySettings(value: unknown, path: string): MemorySettings {
       input.lexicalIndex === undefined
         ? defaults.lexicalIndex
         : expectBoolean(input.lexicalIndex, `${path}.lexicalIndex`),
+    sessionMemory: parseSessionMemoryPolicy(
+      isPlainRecord(input.sessionMemory) ? input.sessionMemory : defaults.sessionMemory,
+    ),
   };
 }
 
@@ -311,6 +321,10 @@ 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"

package/src/config/store.ts

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { ensureOkfKnowledgeBase } from "../knowledge/index.ts";
+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";

package/src/daemon/index.ts

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { type IncomingMessage, createServer } from "node:http";
 import { dirname, join } from "node:path";
-import { listEvolutionTriggers, processEvolutionTriggers } from "../evolution/index.ts";
+import { listEvolutionTriggers, processEvolutionTriggers } from "../evolution/control/index.ts";
 import { listObservabilityEvents } from "../observability/index.ts";
 import {
   type TeamRuntimeAdapter,

package/src/evolution/candidates/index.ts

@@ -0,0 +1,235 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { resolveEvoDevPaths } from "../../config/paths.ts";
+import { pathExists, readJsonFiles, writeJsonFile as writeJson } from "../../utils/index.ts";
+import { resolveEvolutionPaths } from "../paths.ts";
+import type {
+  EvolutionEvosCase,
+  EvolutionEvosCaseQueryResult,
+  EvolutionKnowledgeRecord,
+  EvolutionRepoProposal,
+  EvolutionReviewCandidate,
+  EvolutionReviewSnapshot,
+  EvolutionReviewState,
+  EvolutionTriggerRecord,
+} from "../schema.ts";
+import {
+  listDirectoryNames,
+  parseEvosCase,
+  parseKnowledgeRecord,
+  parseRepoProposal,
+  parseReviewCandidate,
+  parseTrigger,
+  sanitizeId,
+  sanitizeStorageId,
+  uniqueSorted,
+  validateEvolutionKnowledgeRecord,
+} from "../shared.ts";
+
+export async function readEvolutionReviewSnapshot(input: {
+  homeDir: string;
+  projectKey?: string;
+}): Promise<EvolutionReviewSnapshot> {
+  const paths = resolveEvoDevPaths(input.homeDir);
+  const projectKeys =
+    input.projectKey === undefined
+      ? await listEvolutionReviewProjectKeys(paths)
+      : [sanitizeStorageId("projectKey", input.projectKey)];
+  const knowledgeRecords: EvolutionKnowledgeRecord[] = [];
+  const evosCases: EvolutionEvosCase[] = [];
+  const repoProposals: EvolutionRepoProposal[] = [];
+  const reviewCandidates: EvolutionReviewCandidate[] = [];
+  const triggers: EvolutionTriggerRecord[] = [];
+
+  for (const projectKey of projectKeys) {
+    const resolved = resolveEvolutionPaths({
+      homeDir: input.homeDir,
+      projectKey,
+      runId: "review",
+    });
+    knowledgeRecords.push(
+      ...(await readJsonFiles(resolved.knowledgeRecordsDir, parseKnowledgeRecord)),
+    );
+    evosCases.push(...(await readJsonFiles(resolved.evosCasesProjectDir, parseEvosCase)));
+  }
+
+  const evolutionStateDir = join(paths.stateDir, "evolution");
+  const stateProjectKeys =
+    input.projectKey === undefined
+      ? await listDirectoryNames(evolutionStateDir)
+      : [sanitizeStorageId("projectKey", input.projectKey)];
+  for (const projectKey of stateProjectKeys) {
+    const projectStateDir = join(evolutionStateDir, projectKey);
+    const runIds = await listDirectoryNames(projectStateDir);
+    for (const runId of runIds) {
+      const proposalsDir = join(projectStateDir, runId, "proposals");
+      const reviewCandidatesDir = join(projectStateDir, runId, "review-candidates");
+      repoProposals.push(...(await readJsonFiles(proposalsDir, parseRepoProposal)));
+      reviewCandidates.push(...(await readJsonFiles(reviewCandidatesDir, parseReviewCandidate)));
+      triggers.push(
+        ...(await readJsonFiles(join(projectStateDir, runId, "triggers"), parseTrigger)),
+      );
+    }
+  }
+
+  return {
+    projectKey:
+      input.projectKey === undefined ? null : sanitizeStorageId("projectKey", input.projectKey),
+    knowledgeRecords,
+    evosCases,
+    repoProposals,
+    reviewCandidates,
+    triggers,
+  };
+}
+
+async function listEvolutionReviewProjectKeys(
+  paths: ReturnType<typeof resolveEvoDevPaths>,
+): Promise<string[]> {
+  const legacyKnowledgeProjectKeys = (
+    await Promise.all(
+      (
+        await listDirectoryNames(paths.knowledgeDir)
+      ).map(async (projectKey) =>
+        (await pathExists(join(paths.knowledgeDir, projectKey, "records"))) ? projectKey : null,
+      ),
+    )
+  ).filter((projectKey): projectKey is string => projectKey !== null);
+  return uniqueSorted([
+    ...legacyKnowledgeProjectKeys,
+    ...(await listDirectoryNames(paths.evosCasesDir)),
+  ]);
+}
+
+export async function listEvolutionKnowledgeRecords(input: {
+  homeDir: string;
+  projectKey?: string;
+}): Promise<EvolutionKnowledgeRecord[]> {
+  return (
+    await readEvolutionReviewSnapshot({
+      homeDir: input.homeDir,
+      projectKey: input.projectKey,
+    })
+  ).knowledgeRecords.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export async function listEvolutionEvosCases(input: {
+  homeDir: string;
+  projectKey?: string;
+  roleId?: string;
+  reviewStates?: EvolutionReviewState[];
+}): Promise<EvolutionEvosCaseQueryResult> {
+  const paths = resolveEvoDevPaths(input.homeDir);
+  const projectKeys =
+    input.projectKey === undefined
+      ? await listDirectoryNames(paths.evosCasesDir)
+      : [sanitizeStorageId("projectKey", input.projectKey)];
+  const roleId = input.roleId === undefined ? null : sanitizeId(input.roleId);
+  const reviewStates = input.reviewStates ?? ["accepted", "auto-accepted"];
+  const cases: EvolutionEvosCase[] = [];
+  const warnings: string[] = [];
+
+  for (const projectKey of projectKeys) {
+    const projectDir = join(paths.evosCasesDir, projectKey);
+    if (!(await pathExists(projectDir))) continue;
+    const entries = await readdir(projectDir, { withFileTypes: true });
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const sourceLink = `cases/${projectKey}/${entry.name}`;
+      try {
+        const value = JSON.parse(await readFile(join(projectDir, entry.name), "utf8")) as unknown;
+        const evosCase = parseEvosCase(value);
+        if (!reviewStates.includes(evosCase.reviewState)) continue;
+        if (
+          roleId !== null &&
+          evosCase.roleTags.length > 0 &&
+          !evosCase.roleTags.includes(roleId)
+        ) {
+          continue;
+        }
+        cases.push(evosCase);
+      } catch {
+        warnings.push(
+          `Omitted unsafe or invalid evos case: ${sourceLink}. Run evodev knowledge lint.`,
+        );
+      }
+    }
+  }
+
+  return {
+    cases: cases.sort((left, right) => {
+      const project = left.projectKey.localeCompare(right.projectKey);
+      if (project !== 0) return project;
+      return left.id.localeCompare(right.id);
+    }),
+    warnings,
+  };
+}
+
+export async function readEvolutionKnowledgeRecordById(input: {
+  homeDir: string;
+  knowledgeId: string;
+  projectKey?: string;
+}): Promise<EvolutionKnowledgeRecord> {
+  const matches = (await listEvolutionKnowledgeRecords(input)).filter(
+    (record) => record.id === input.knowledgeId,
+  );
+  if (matches.length === 0) throw new Error(`Knowledge record not found: ${input.knowledgeId}`);
+  if (matches.length > 1) {
+    throw new Error(`Knowledge record id is ambiguous across projects: ${input.knowledgeId}`);
+  }
+  return matches[0] as EvolutionKnowledgeRecord;
+}
+
+export async function updateEvolutionKnowledgeReviewState(input: {
+  homeDir: string;
+  knowledgeId: string;
+  projectKey?: string;
+  reviewState: "accepted" | "rejected" | "deferred";
+}): Promise<{ path: string; record: EvolutionKnowledgeRecord }> {
+  const record = await readEvolutionKnowledgeRecordById(input);
+  const next: EvolutionKnowledgeRecord = {
+    ...record,
+    reviewState: input.reviewState,
+    authority: input.reviewState === "accepted" ? "reviewed" : "contextual",
+    runtime: {
+      ...record.runtime,
+      canLoad: input.reviewState === "accepted",
+      hardBlocking: false,
+    },
+  };
+  validateEvolutionKnowledgeRecord(next);
+  const paths = resolveEvolutionPaths({
+    homeDir: input.homeDir,
+    projectKey: next.projectKey,
+    runId: "review",
+  });
+  const path = join(paths.knowledgeRecordsDir, `${next.id}.json`);
+  await writeJson(path, next, { overwrite: true });
+  const allProjectKnowledgeRecords = await readJsonFiles(
+    paths.knowledgeRecordsDir,
+    parseKnowledgeRecord,
+  );
+  await writeJson(
+    paths.knowledgeIndexPath,
+    {
+      version: 1,
+      kind: "evolution-knowledge-index",
+      projectKey: next.projectKey,
+      updatedAt: new Date().toISOString(),
+      records: allProjectKnowledgeRecords.map((item) => ({
+        id: item.id,
+        kind: item.kind,
+        title: item.title,
+        roleTags: item.roleTags,
+        tags: item.tags,
+        reviewState: item.reviewState,
+        authority: item.authority,
+        confidence: item.confidence,
+        runtime: item.runtime,
+      })),
+    },
+    { overwrite: true },
+  );
+  return { path, record: next };
+}

package/src/evolution/control/index.ts

@@ -0,0 +1,19 @@
+export {
+  formatEvolutionProcessResult,
+  formatEvolutionReviewSnapshot,
+} from "../formatters.ts";
+export { processEvolutionTriggers } from "../processor/index.ts";
+export { readEvolutionReviewSnapshot } from "../candidates/index.ts";
+export {
+  listEvolutionTriggers,
+  listSegmentEvolutionTriggers,
+} from "../triggers/index.ts";
+export type {
+  EvolutionProcessInput,
+  EvolutionProcessResult,
+  EvolutionReviewSnapshot,
+  EvolutionTriggerListInput,
+  EvolutionTriggerRecord,
+  SegmentEvolutionTriggerListInput,
+  SegmentEvolutionTriggerRecord,
+} from "../schema.ts";