@evo-dev/core 0.0.1-alpha.2 → 0.0.1-alpha.20

package/src/utils/fs.ts

@@ -0,0 +1,40 @@
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { isNotFoundError } from "./errors.ts";
+
+export async function pathExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (isNotFoundError(error)) return false;
+    throw error;
+  }
+}
+
+export async function readJsonFile<T>(path: string, parse: (value: unknown) => T): Promise<T> {
+  return parse(JSON.parse(await readFile(path, "utf8")) as unknown);
+}
+
+export async function readJsonFiles<T>(dir: string, parse: (value: unknown) => T): Promise<T[]> {
+  if (!(await pathExists(dir))) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  const values: T[] = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    values.push(await readJsonFile(join(dir, entry.name), parse));
+  }
+  return values;
+}
+
+export async function writeJsonFile(
+  path: string,
+  value: unknown,
+  options: { overwrite?: boolean } = {},
+): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, {
+    encoding: "utf8",
+    flag: options.overwrite === false ? "wx" : "w",
+  });
+}

package/src/utils/hash.ts

@@ -0,0 +1,9 @@
+import { createHash } from "node:crypto";
+
+export function sha256Hex(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export function sha256Short(value: string, length = 16): string {
+  return sha256Hex(value).slice(0, length);
+}

package/src/utils/ids.ts

@@ -0,0 +1,12 @@
+import { sha256Short } from "./hash.ts";
+
+export function createStableId(prefix: string, parts: string[]): string {
+  return `${prefix}-${sha256Short(parts.join("\0"))}`;
+}
+
+export function sanitizeStorageId(value: string, fallbackPrefix: string): string {
+  const sanitized = value.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120);
+  return sanitized === "" || sanitized === "." || sanitized === ".."
+    ? `${fallbackPrefix}-local`
+    : sanitized;
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from "./errors.ts";
+export * from "./fs.ts";
+export * from "./hash.ts";
+export * from "./ids.ts";
+export * from "./parsing.ts";
+export * from "./text.ts";
+export * from "./time.ts";

package/src/utils/parsing.ts

@@ -0,0 +1,11 @@
+export function optionalString(value: unknown): string | null {
+  return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+
+export function optionalBoolean(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+export function positiveInteger(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}

package/src/utils/text.ts

@@ -0,0 +1,18 @@
+export function sanitizeSummary(value: string): string {
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  return trimmed.length === 0 ? "Session memory event observed." : trimmed.slice(0, 600);
+}
+
+export function truncateUtf8Tail(
+  value: string,
+  maxBytes: number,
+): { content: string; truncated: boolean } {
+  if (Buffer.byteLength(value, "utf8") <= maxBytes) {
+    return { content: value, truncated: false };
+  }
+  let content = value.slice(Math.max(0, value.length - maxBytes));
+  while (Buffer.byteLength(content, "utf8") > maxBytes && content.length > 0) {
+    content = content.slice(1);
+  }
+  return { content, truncated: true };
+}

package/src/utils/time.ts

@@ -0,0 +1,5 @@
+export function normalizeTimestamp(value?: string | Date): string {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" && value.trim() !== "") return new Date(value).toISOString();
+  return new Date().toISOString();
+}

package/src/workflow/index.ts

@@ -1,6 +1,5 @@
 import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
-import type { TaskContract } from "../task/index.ts";
 
 export type WorkflowMode = "minimal" | "standard" | "rigorous";
 
@@ -36,8 +35,6 @@ export interface WorkflowStep {
 
 export interface WorkflowPlan {
   workflow: WorkflowManifest;
-  taskId?: string;
-  mode: WorkflowMode | null;
   steps: Array<WorkflowStep & { plannedOnly: true }>;
   requiredEvidence: string[];
   warnings: string[];
@@ -78,26 +75,13 @@ export function parseWorkflowManifest(value: unknown): WorkflowManifest {
   return manifest;
 }
 
-export function planWorkflow(input: {
-  workflow: WorkflowManifest;
-  contract?: TaskContract;
-}): WorkflowPlan {
-  const mode = input.contract?.route.mode ?? null;
-  const warnings: string[] = [];
-  const advisories: string[] = [];
-
-  if (mode !== null && !input.workflow.modes.includes(mode)) {
-    advisories.push(`Workflow ${input.workflow.id} does not list task mode ${mode}.`);
-  }
-
+export function planWorkflow(input: { workflow: WorkflowManifest }): WorkflowPlan {
   return {
     workflow: input.workflow,
-    taskId: input.contract?.taskId,
-    mode,
     steps: input.workflow.steps.map((step) => ({ ...step, plannedOnly: true })),
     requiredEvidence: input.workflow.requiredEvidence,
-    warnings,
-    advisories,
+    warnings: [],
+    advisories: [],
   };
 }
 
@@ -116,8 +100,6 @@ export function formatWorkflowPlan(plan: WorkflowPlan): string {
     "EvoDev workflow dry-run",
     "",
     `Workflow: ${plan.workflow.id}`,
-    `Task: ${plan.taskId ?? "none"}`,
-    `Mode: ${plan.mode ?? "not routed"}`,
     "",
     "Steps:",
     ...plan.steps.map(

package/src/project/index.ts

@@ -1,507 +0,0 @@
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { basename, join, relative } from "node:path";
-
-export const PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS = [
-  ".evodev/project.json",
-  ".evodev/profile.md",
-  ".evodev/index.json",
-  ".evodev/commands.json",
-  ".evodev/privacy.json",
-  ".evodev/decisions/README.md",
-] as const;
-
-export type ProjectContextAllowedRelativePath =
-  (typeof PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS)[number];
-
-export type ProjectContextPlanAction = "create" | "error";
-
-export interface ProjectContextPlanEntry {
-  relativePath: ProjectContextAllowedRelativePath;
-  absolutePath: string;
-  action: ProjectContextPlanAction;
-  reason: string;
-}
-
-export interface ProjectContextPlan {
-  projectDir: string;
-  projectId: string;
-  files: ProjectContextPlanEntry[];
-  index: ProjectIndex;
-  commands: ProjectCommands;
-  privacy: ProjectPrivacy;
-  warnings: string[];
-  errors: string[];
-}
-
-export interface ProjectProfile {
-  version: 1;
-  projectId: string;
-  displayName: string;
-  root: {
-    pathPolicy: "local-only";
-  };
-  privacy: {
-    classification: "local-private";
-    metadataOnly: true;
-    sourceContentIncluded: false;
-    rawCommandsIncluded: false;
-  };
-}
-
-export interface ProjectIndex {
-  version: 1;
-  mode: "metadata-only";
-  projectId: string;
-  generatedAt: null;
-  rootName: string;
-  files: ProjectFileMetadata[];
-  docs: {
-    entrypoints: string[];
-  };
-  commands: {
-    scripts: ProjectScriptSummary[];
-    testCommandCandidates: string[];
-  };
-  exclusions: string[];
-  sourceContentIncluded: false;
-}
-
-export interface ProjectFileMetadata {
-  path: string;
-  kind: "file" | "directory";
-  sizeBytes?: number;
-}
-
-export interface ProjectCommands {
-  version: 1;
-  metadataOnly: true;
-  rawCommandsIncluded: false;
-  scripts: ProjectScriptSummary[];
-  warnings: string[];
-}
-
-export interface ProjectScriptSummary {
-  name: string;
-  commandClass: ProjectCommandClass;
-  summary: string;
-  rawCommandStored: false;
-  redacted: boolean;
-  warning?: string;
-}
-
-export type ProjectCommandClass =
-  | "build"
-  | "format"
-  | "install"
-  | "lint"
-  | "other"
-  | "release"
-  | "test"
-  | "typecheck";
-
-export interface ProjectPrivacy {
-  version: 1;
-  classification: "local-private";
-  metadataOnly: true;
-  sourceContentIndex: false;
-  promptHistoryIndex: false;
-  shellHistoryIndex: false;
-  rawCommandOutputIndex: false;
-  externalUpload: false;
-  excludedGlobs: string[];
-  protectedPatterns: string[];
-}
-
-export interface WriteProjectContextResult {
-  writtenFiles: ProjectContextAllowedRelativePath[];
-}
-
-const EXCLUDED_DIRECTORY_NAMES = new Set([
-  ".git",
-  ".claude",
-  ".codex",
-  "backups",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules",
-]);
-
-const EXCLUDED_FILE_PREFIXES = [".env"];
-const EXCLUDED_FILE_PARTS = [
-  "api-key",
-  "api_key",
-  "apikey",
-  "credential",
-  "credentials",
-  "internal",
-  "internal-link",
-  "password",
-  "passwords",
-  "passwd",
-  "private",
-  "private-url",
-  "secret",
-  "token",
-];
-const EXCLUDED_FILE_EXTENSIONS = [".key", ".pem", ".p12", ".pfx"];
-const DOC_ENTRYPOINTS = new Set(["README.md"]);
-const DEFAULT_EXCLUDED_GLOBS = [
-  ".git/**",
-  "node_modules/**",
-  "dist/**",
-  "build/**",
-  "coverage/**",
-  ".env*",
-  "**/*secret*",
-  "**/*token*",
-  "**/*password*",
-  "**/*passwd*",
-  "**/*api-key*",
-  "**/*api_key*",
-  "**/*apikey*",
-  "**/*credential*",
-  "**/*private*",
-  "**/*internal*",
-  "**/*.key",
-  "**/*.pem",
-  ".claude/**",
-  ".codex/**",
-  ".evodev/backups/**",
-];
-const PROTECTED_PATTERNS = [
-  "secret",
-  "token",
-  "password",
-  "passwd",
-  "api-key",
-  "credential",
-  "private",
-  "private-url",
-  "internal",
-  "internal-link",
-];
-
-export async function createProjectContextPlan(projectDir: string): Promise<ProjectContextPlan> {
-  const projectDirStat = await stat(projectDir);
-  if (!projectDirStat.isDirectory()) {
-    throw new Error(`Project dir is not a directory: ${projectDir}`);
-  }
-
-  const projectId = createProjectId(projectDir);
-  const privacy = createProjectPrivacy();
-  const files = await collectProjectFileMetadata(projectDir);
-  const commands = await collectProjectCommands(projectDir);
-  const docs = files
-    .filter((file) => file.kind === "file" && DOC_ENTRYPOINTS.has(basename(file.path)))
-    .map((file) => file.path)
-    .sort();
-  const index: ProjectIndex = {
-    version: 1,
-    mode: "metadata-only",
-    projectId,
-    generatedAt: null,
-    rootName: basename(projectDir),
-    files,
-    docs: { entrypoints: docs },
-    commands: {
-      scripts: commands.scripts,
-      testCommandCandidates: commands.scripts
-        .filter((script) => script.commandClass === "test")
-        .map((script) => script.name),
-    },
-    exclusions: privacy.excludedGlobs,
-    sourceContentIncluded: false,
-  };
-  const planFiles = await Promise.all(
-    PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS.map(async (relativePath) => {
-      const absolutePath = join(projectDir, relativePath);
-      const exists = await pathExists(absolutePath);
-      return {
-        relativePath,
-        absolutePath,
-        action: exists ? "error" : "create",
-        reason: exists
-          ? "Target already exists; I1 does not overwrite."
-          : "Allowed project context file.",
-      } satisfies ProjectContextPlanEntry;
-    }),
-  );
-  const errors = planFiles
-    .filter((file) => file.action === "error")
-    .map((file) => `${file.relativePath}: ${file.reason}`);
-
-  return {
-    projectDir,
-    projectId,
-    files: planFiles,
-    index,
-    commands,
-    privacy,
-    warnings: commands.warnings,
-    errors,
-  };
-}
-
-export async function writeProjectContext(
-  plan: ProjectContextPlan,
-): Promise<WriteProjectContextResult> {
-  if (plan.errors.length > 0) {
-    throw new Error(`Cannot write project context:\n${plan.errors.join("\n")}`);
-  }
-
-  const payloads = createProjectContextPayloads(plan);
-  const writtenFiles: ProjectContextAllowedRelativePath[] = [];
-
-  for (const relativePath of PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS) {
-    const content = payloads[relativePath];
-    const absolutePath = join(plan.projectDir, relativePath);
-    await mkdir(join(absolutePath, ".."), { recursive: true });
-    await writeFile(absolutePath, content, { encoding: "utf8", flag: "wx" });
-    writtenFiles.push(relativePath);
-  }
-
-  return { writtenFiles };
-}
-
-export function formatProjectContextPlan(
-  plan: ProjectContextPlan,
-  mode: "dry-run" | "write",
-): string {
-  return [
-    "EvoDev project init",
-    "",
-    `Mode: ${mode}`,
-    `Project: ${plan.projectDir}`,
-    `Project id: ${plan.projectId}`,
-    "",
-    "Plan:",
-    ...plan.files.map((file) => `  - ${file.action}: ${file.relativePath} (${file.reason})`),
-    "",
-    "Metadata-only index summary:",
-    `  - files: ${plan.index.files.filter((file) => file.kind === "file").length}`,
-    `  - directories: ${plan.index.files.filter((file) => file.kind === "directory").length}`,
-    `  - docs: ${plan.index.docs.entrypoints.length}`,
-    `  - package scripts: ${plan.commands.scripts.length}`,
-    ...plan.warnings.map((warning) => `Warning: ${warning}`),
-    ...plan.errors.map((error) => `Error: ${error}`),
-  ].join("\n");
-}
-
-function createProjectContextPayloads(
-  plan: ProjectContextPlan,
-): Record<ProjectContextAllowedRelativePath, string> {
-  const profile: ProjectProfile = {
-    version: 1,
-    projectId: plan.projectId,
-    displayName: basename(plan.projectDir),
-    root: { pathPolicy: "local-only" },
-    privacy: {
-      classification: "local-private",
-      metadataOnly: true,
-      sourceContentIncluded: false,
-      rawCommandsIncluded: false,
-    },
-  };
-
-  return {
-    ".evodev/project.json": `${JSON.stringify(profile, null, 2)}\n`,
-    ".evodev/profile.md": createProfileMarkdown(plan),
-    ".evodev/index.json": `${JSON.stringify(plan.index, null, 2)}\n`,
-    ".evodev/commands.json": `${JSON.stringify(plan.commands, null, 2)}\n`,
-    ".evodev/privacy.json": `${JSON.stringify(plan.privacy, null, 2)}\n`,
-    ".evodev/decisions/README.md": "# Project Decisions\n\nRecord project decisions here.\n",
-  };
-}
-
-function createProfileMarkdown(plan: ProjectContextPlan): string {
-  return [
-    `# ${basename(plan.projectDir)} Project Context`,
-    "",
-    "This project context was generated as metadata-only local state.",
-    "",
-    `- Project id: ${plan.projectId}`,
-    "- Source content included: false",
-    "- Raw package script commands included: false",
-    "- External upload: false",
-    "",
-  ].join("\n");
-}
-
-async function collectProjectFileMetadata(projectDir: string): Promise<ProjectFileMetadata[]> {
-  const files: ProjectFileMetadata[] = [];
-
-  async function visit(dir: string): Promise<void> {
-    const entries = await readdir(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const absolutePath = join(dir, entry.name);
-      const relativePath = relative(projectDir, absolutePath).replaceAll("\\", "/");
-      if (shouldExcludePath(relativePath, entry.isDirectory())) {
-        continue;
-      }
-
-      if (entry.isDirectory()) {
-        files.push({ path: relativePath, kind: "directory" });
-        await visit(absolutePath);
-        continue;
-      }
-
-      if (entry.isFile()) {
-        const fileStat = await stat(absolutePath);
-        files.push({ path: relativePath, kind: "file", sizeBytes: fileStat.size });
-      }
-    }
-  }
-
-  await visit(projectDir);
-  return files.sort((left, right) => left.path.localeCompare(right.path));
-}
-
-async function collectProjectCommands(projectDir: string): Promise<ProjectCommands> {
-  const packageJsonPath = join(projectDir, "package.json");
-  const warnings: string[] = [];
-
-  if (!(await pathExists(packageJsonPath))) {
-    return { version: 1, metadataOnly: true, rawCommandsIncluded: false, scripts: [], warnings };
-  }
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(await readFile(packageJsonPath, "utf8"));
-  } catch (error) {
-    warnings.push(`package.json scripts skipped: ${describeError(error)}`);
-    return { version: 1, metadataOnly: true, rawCommandsIncluded: false, scripts: [], warnings };
-  }
-
-  const scripts = isRecord(parsed) && isRecord(parsed.scripts) ? parsed.scripts : {};
-  const summaries: ProjectScriptSummary[] = [];
-
-  for (const [name, value] of Object.entries(scripts).sort(([left], [right]) =>
-    left.localeCompare(right),
-  )) {
-    if (typeof value !== "string") {
-      continue;
-    }
-
-    const commandClass = classifyScript(name, value);
-    const sensitiveReason = detectSensitiveScript(`${name} ${value}`);
-    if (sensitiveReason !== null) {
-      const safeName = `redacted-${commandClass}-script`;
-      const warning = `Protected ${commandClass} script name/command omitted because it matched protected pattern: ${sensitiveReason}.`;
-      warnings.push(warning);
-      summaries.push({
-        name: safeName,
-        commandClass,
-        summary: `Protected ${commandClass} script name/command omitted.`,
-        rawCommandStored: false,
-        redacted: true,
-        warning,
-      });
-      continue;
-    }
-
-    summaries.push({
-      name,
-      commandClass,
-      summary: `Safe ${commandClass} script command summary only.`,
-      rawCommandStored: false,
-      redacted: false,
-    });
-  }
-
-  return {
-    version: 1,
-    metadataOnly: true,
-    rawCommandsIncluded: false,
-    scripts: summaries,
-    warnings,
-  };
-}
-
-function classifyScript(name: string, command: string): ProjectCommandClass {
-  const text = `${name} ${command}`.toLowerCase();
-  if (text.includes("typecheck") || text.includes("tsc")) return "typecheck";
-  if (text.includes("lint") || text.includes("biome") || text.includes("eslint")) return "lint";
-  if (text.includes("test")) return "test";
-  if (text.includes("build")) return "build";
-  if (text.includes("format") || text.includes("prettier")) return "format";
-  if (text.includes("install")) return "install";
-  if (text.includes("release") || text.includes("publish") || text.includes("pack"))
-    return "release";
-  return "other";
-}
-
-function detectSensitiveScript(command: string): string | null {
-  const lower = command.toLowerCase();
-  if (
-    /(^|[^a-z0-9])(secret|token|password|passwd|api[_-]?key|apikey|credential|credentials|private|internal|private-url|internal-link)([^a-z0-9]|$)/.test(
-      lower,
-    )
-  )
-    return "protected-name-or-command";
-  if (/https?:\/\//i.test(command)) return "url";
-  if (/\b[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}\b/i.test(command)) return "email-or-internal-id";
-  return null;
-}
-
-function createProjectPrivacy(): ProjectPrivacy {
-  return {
-    version: 1,
-    classification: "local-private",
-    metadataOnly: true,
-    sourceContentIndex: false,
-    promptHistoryIndex: false,
-    shellHistoryIndex: false,
-    rawCommandOutputIndex: false,
-    externalUpload: false,
-    excludedGlobs: DEFAULT_EXCLUDED_GLOBS,
-    protectedPatterns: PROTECTED_PATTERNS,
-  };
-}
-
-function createProjectId(projectDir: string): string {
-  return (
-    basename(projectDir)
-      .toLowerCase()
-      .replace(/[^a-z0-9._-]+/g, "-")
-      .replace(/^-+|-+$/g, "") || "project"
-  );
-}
-
-function shouldExcludePath(relativePath: string, isDirectory: boolean): boolean {
-  const segments = relativePath.split("/");
-  const name = segments.at(-1) ?? relativePath;
-  const lowerName = name.toLowerCase();
-
-  if (isDirectory && EXCLUDED_DIRECTORY_NAMES.has(name)) return true;
-  if (segments.includes(".evodev") && !relativePath.startsWith(".evodev/decisions")) return true;
-  if (EXCLUDED_FILE_PREFIXES.some((prefix) => name.startsWith(prefix))) return true;
-  if (EXCLUDED_FILE_PARTS.some((part) => lowerName.includes(part))) return true;
-  if (EXCLUDED_FILE_EXTENSIONS.some((extension) => lowerName.endsWith(extension))) return true;
-  return false;
-}
-
-async function pathExists(path: string): Promise<boolean> {
-  try {
-    await stat(path);
-    return true;
-  } catch (error) {
-    if (
-      error instanceof Error &&
-      "code" in error &&
-      (error as NodeJS.ErrnoException).code === "ENOENT"
-    ) {
-      return false;
-    }
-    throw error;
-  }
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function describeError(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}