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

package/src/projects/index.ts

@@ -0,0 +1,453 @@
+import { lstat, readFile, readdir, realpath, stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, parse } from "node:path";
+import { resolveEvoDevPaths } from "../config/paths.ts";
+import { resolveProjectLogKey } from "../runtime-logs/index.ts";
+import {
+  isFileExistsError,
+  isNotFoundError,
+  normalizeTimestamp,
+  sanitizeStorageId,
+  sha256Short,
+  writeJsonFile,
+} from "../utils/index.ts";
+
+export type ProjectWorkspaceKind = "git" | "directory";
+export type ProjectDiscoveryTarget = "claude" | "codex";
+
+export interface ResolvedProjectWorkspace {
+  projectKey: string;
+  displayName: string;
+  workspaceRoot: string;
+  workspaceKind: ProjectWorkspaceKind;
+  cwd: string;
+}
+
+export interface DiscoveredProjectRecordV1 {
+  schemaVersion: 1;
+  kind: "discovered-project";
+  projectKey: string;
+  displayName: string;
+  workspaceRoot: string;
+  lastCwd: string;
+  workspaceKind: ProjectWorkspaceKind;
+  sourceTargets: ProjectDiscoveryTarget[];
+  lastSessionKey: string | null;
+  firstSeenAt: string;
+  lastSeenAt: string;
+  localOnly: true;
+  sourceContentStored: false;
+}
+
+export interface RegisteredProjectRecordV1 {
+  schemaVersion: 1;
+  kind: "registered-project";
+  projectKey: string;
+  displayName: string;
+  workspaceRoot: string;
+  workspaceKind: ProjectWorkspaceKind;
+  registeredAt: string;
+  lastSeenAt: string;
+  localOnly: true;
+  sourceContentStored: false;
+}
+
+export class ProjectRegistrationError extends Error {
+  readonly code: "invalid" | "not-found" | "conflict";
+
+  constructor(code: "invalid" | "not-found" | "conflict", message: string) {
+    super(message);
+    this.name = "ProjectRegistrationError";
+    this.code = code;
+  }
+}
+
+export function resolveProjectRegistryPaths(homeDir: string): {
+  discoveredDir: string;
+  registeredDir: string;
+  discoveredPath: (projectKey: string) => string;
+  registeredPath: (projectKey: string) => string;
+} {
+  const paths = resolveEvoDevPaths(homeDir);
+  const discoveredDir = join(paths.stateDir, "projects", "discovered");
+  const registeredDir = join(paths.rootDir, "projects");
+  return {
+    discoveredDir,
+    registeredDir,
+    discoveredPath: (projectKey) => join(discoveredDir, `${projectKey}.json`),
+    registeredPath: (projectKey) => join(registeredDir, projectKey, "workspace.json"),
+  };
+}
+
+export async function resolveProjectWorkspaceFromCwd(input: {
+  homeDir: string;
+  cwd: string;
+}): Promise<ResolvedProjectWorkspace | null> {
+  if (!isAbsolute(input.cwd)) return null;
+
+  let cwd: string;
+  try {
+    const info = await stat(input.cwd);
+    if (!info.isDirectory()) return null;
+    cwd = await realpath(input.cwd);
+  } catch (error) {
+    if (isNotFoundError(error)) return null;
+    throw error;
+  }
+
+  const gitRoot = await findNearestGitRoot(cwd);
+  const workspaceRoot = gitRoot ?? cwd;
+  return {
+    projectKey: sanitizeStorageId(resolveProjectLogKey(input.homeDir, workspaceRoot), "project"),
+    displayName: basename(workspaceRoot) || parse(workspaceRoot).root,
+    workspaceRoot,
+    workspaceKind: gitRoot === null ? "directory" : "git",
+    cwd,
+  };
+}
+
+export async function recordDiscoveredProject(input: {
+  homeDir: string;
+  cwd: string;
+  target: ProjectDiscoveryTarget;
+  sessionKey?: string | null;
+  now?: Date | string;
+}): Promise<{ record: DiscoveredProjectRecordV1; path: string } | null> {
+  const workspace = await resolveProjectWorkspaceFromCwd(input);
+  if (workspace === null) return null;
+
+  const now = normalizeTimestamp(input.now);
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const path = paths.discoveredPath(workspace.projectKey);
+  const existing = await readDiscoveredProject(path);
+  const record: DiscoveredProjectRecordV1 = {
+    schemaVersion: 1,
+    kind: "discovered-project",
+    projectKey: workspace.projectKey,
+    displayName: workspace.displayName,
+    workspaceRoot: workspace.workspaceRoot,
+    lastCwd: workspace.cwd,
+    workspaceKind: workspace.workspaceKind,
+    sourceTargets: mergeTargets(existing?.sourceTargets ?? [], [input.target]),
+    lastSessionKey: normalizeSessionKey(input.sessionKey ?? existing?.lastSessionKey ?? null),
+    firstSeenAt: existing?.firstSeenAt ?? now,
+    lastSeenAt: now,
+    localOnly: true,
+    sourceContentStored: false,
+  };
+  await writeJsonFile(path, record);
+  return { record, path };
+}
+
+export async function listDiscoveredProjects(input: {
+  homeDir: string;
+}): Promise<DiscoveredProjectRecordV1[]> {
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const records = new Map<string, DiscoveredProjectRecordV1>();
+
+  for (const path of await listJsonFilePaths(paths.discoveredDir)) {
+    const record = await readDiscoveredProject(path);
+    if (record !== null) mergeDiscoveredRecord(records, record);
+  }
+
+  for (const binding of await listLegacyHookBindings(input.homeDir)) {
+    if (binding.cwd === null) continue;
+    const workspace = await resolveProjectWorkspaceFromCwd({
+      homeDir: input.homeDir,
+      cwd: binding.cwd,
+    });
+    if (workspace === null) continue;
+    mergeDiscoveredRecord(records, {
+      schemaVersion: 1,
+      kind: "discovered-project",
+      projectKey: workspace.projectKey,
+      displayName: workspace.displayName,
+      workspaceRoot: workspace.workspaceRoot,
+      lastCwd: workspace.cwd,
+      workspaceKind: workspace.workspaceKind,
+      sourceTargets: [binding.target],
+      lastSessionKey: normalizeSessionKey(binding.sessionKey),
+      firstSeenAt: binding.updatedAt,
+      lastSeenAt: binding.updatedAt,
+      localOnly: true,
+      sourceContentStored: false,
+    });
+  }
+
+  return [...records.values()].sort(
+    (left, right) =>
+      right.lastSeenAt.localeCompare(left.lastSeenAt) ||
+      left.projectKey.localeCompare(right.projectKey),
+  );
+}
+
+export async function listRegisteredProjects(input: {
+  homeDir: string;
+}): Promise<RegisteredProjectRecordV1[]> {
+  const { registeredDir } = resolveProjectRegistryPaths(input.homeDir);
+  const records: RegisteredProjectRecordV1[] = [];
+  for (const projectKey of await listDirectoryNames(registeredDir)) {
+    const record = await readRegisteredProject(join(registeredDir, projectKey, "workspace.json"));
+    if (record !== null && record.projectKey === projectKey) records.push(record);
+  }
+  return records.sort(
+    (left, right) =>
+      right.lastSeenAt.localeCompare(left.lastSeenAt) ||
+      left.projectKey.localeCompare(right.projectKey),
+  );
+}
+
+export async function registerDiscoveredProject(input: {
+  homeDir: string;
+  projectKey: string;
+  now?: Date | string;
+}): Promise<{ record: RegisteredProjectRecordV1; path: string; changed: boolean }> {
+  assertProjectKey(input.projectKey);
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const path = paths.registeredPath(input.projectKey);
+  const existing = await readRegisteredProject(path);
+  if (existing !== null) return { record: existing, path, changed: false };
+
+  const discovered = (await listDiscoveredProjects({ homeDir: input.homeDir })).find(
+    (record) => record.projectKey === input.projectKey,
+  );
+  if (discovered === undefined) {
+    throw new ProjectRegistrationError(
+      "not-found",
+      "The project must be discovered by a local Code Agent session before it can be added.",
+    );
+  }
+
+  const record: RegisteredProjectRecordV1 = {
+    schemaVersion: 1,
+    kind: "registered-project",
+    projectKey: discovered.projectKey,
+    displayName: discovered.displayName,
+    workspaceRoot: discovered.workspaceRoot,
+    workspaceKind: discovered.workspaceKind,
+    registeredAt: normalizeTimestamp(input.now),
+    lastSeenAt: discovered.lastSeenAt,
+    localOnly: true,
+    sourceContentStored: false,
+  };
+  try {
+    await writeJsonFile(path, record, { overwrite: false });
+    return { record, path, changed: true };
+  } catch (error) {
+    if (!isFileExistsError(error)) throw error;
+    const concurrent = await readRegisteredProject(path);
+    if (concurrent !== null) return { record: concurrent, path, changed: false };
+    throw new ProjectRegistrationError("conflict", "The project registration already exists.");
+  }
+}
+
+async function findNearestGitRoot(cwd: string): Promise<string | null> {
+  let current = cwd;
+  for (;;) {
+    try {
+      const marker = await lstat(join(current, ".git"));
+      if (marker.isDirectory() || marker.isFile()) return current;
+    } catch (error) {
+      if (!isNotFoundError(error)) throw error;
+    }
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+async function readDiscoveredProject(path: string): Promise<DiscoveredProjectRecordV1 | null> {
+  try {
+    return parseDiscoveredProject(JSON.parse(await readFile(path, "utf8")) as unknown);
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError) return null;
+    throw error;
+  }
+}
+
+async function readRegisteredProject(path: string): Promise<RegisteredProjectRecordV1 | null> {
+  try {
+    return parseRegisteredProject(JSON.parse(await readFile(path, "utf8")) as unknown);
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError) return null;
+    throw error;
+  }
+}
+
+function parseDiscoveredProject(value: unknown): DiscoveredProjectRecordV1 {
+  const record = requireRecord(value);
+  if (
+    record.schemaVersion !== 1 ||
+    record.kind !== "discovered-project" ||
+    !isProjectKey(record.projectKey) ||
+    !isNonEmptyString(record.displayName) ||
+    !isAbsoluteString(record.workspaceRoot) ||
+    !isAbsoluteString(record.lastCwd) ||
+    !isWorkspaceKind(record.workspaceKind) ||
+    !isDiscoveryTargetArray(record.sourceTargets) ||
+    !(record.lastSessionKey === null || isNonEmptyString(record.lastSessionKey)) ||
+    !isNonEmptyString(record.firstSeenAt) ||
+    !isNonEmptyString(record.lastSeenAt) ||
+    record.localOnly !== true ||
+    record.sourceContentStored !== false
+  ) {
+    throw new ProjectRegistrationError("invalid", "Discovered project record is invalid.");
+  }
+  return record as unknown as DiscoveredProjectRecordV1;
+}
+
+function parseRegisteredProject(value: unknown): RegisteredProjectRecordV1 {
+  const record = requireRecord(value);
+  if (
+    record.schemaVersion !== 1 ||
+    record.kind !== "registered-project" ||
+    !isProjectKey(record.projectKey) ||
+    !isNonEmptyString(record.displayName) ||
+    !isAbsoluteString(record.workspaceRoot) ||
+    !isWorkspaceKind(record.workspaceKind) ||
+    !isNonEmptyString(record.registeredAt) ||
+    !isNonEmptyString(record.lastSeenAt) ||
+    record.localOnly !== true ||
+    record.sourceContentStored !== false
+  ) {
+    throw new ProjectRegistrationError("invalid", "Registered project record is invalid.");
+  }
+  return record as unknown as RegisteredProjectRecordV1;
+}
+
+function mergeDiscoveredRecord(
+  records: Map<string, DiscoveredProjectRecordV1>,
+  next: DiscoveredProjectRecordV1,
+): void {
+  const previous = records.get(next.projectKey);
+  if (previous === undefined) {
+    records.set(next.projectKey, next);
+    return;
+  }
+  const newer = next.lastSeenAt >= previous.lastSeenAt ? next : previous;
+  records.set(next.projectKey, {
+    ...newer,
+    sourceTargets: mergeTargets(previous.sourceTargets, next.sourceTargets),
+    firstSeenAt: previous.firstSeenAt <= next.firstSeenAt ? previous.firstSeenAt : next.firstSeenAt,
+    lastSeenAt: previous.lastSeenAt >= next.lastSeenAt ? previous.lastSeenAt : next.lastSeenAt,
+  });
+}
+
+function mergeTargets(
+  left: ProjectDiscoveryTarget[],
+  right: ProjectDiscoveryTarget[],
+): ProjectDiscoveryTarget[] {
+  return [...new Set([...left, ...right])].sort();
+}
+
+function normalizeSessionKey(value: string | null | undefined): string | null {
+  if (value === null || value === undefined) return null;
+  return /^session-[a-f0-9]{16}$/u.test(value) ? value : `session-${sha256Short(value)}`;
+}
+
+interface LegacyHookBinding {
+  target: ProjectDiscoveryTarget;
+  sessionKey: string;
+  cwd: string | null;
+  updatedAt: string;
+}
+
+async function listLegacyHookBindings(homeDir: string): Promise<LegacyHookBinding[]> {
+  const roots = [
+    join(homeDir, ".evodev", "state", "hooks", "sessions"),
+    join(homeDir, ".evodev", "STATE", "hooks", "sessions"),
+  ];
+  const bindings: LegacyHookBinding[] = [];
+  for (const root of roots) {
+    for (const sessionDir of await listDirectoryNames(root)) {
+      try {
+        const value = JSON.parse(
+          await readFile(join(root, sessionDir, "binding.json"), "utf8"),
+        ) as Record<string, unknown> | null;
+        if (
+          value === null ||
+          (value.target !== "claude" && value.target !== "codex") ||
+          !isNonEmptyString(value.sessionKey) ||
+          !(value.cwd === null || isAbsoluteString(value.cwd)) ||
+          !isNonEmptyString(value.updatedAt)
+        ) {
+          continue;
+        }
+        bindings.push({
+          target: value.target,
+          sessionKey: value.sessionKey,
+          cwd: value.cwd,
+          updatedAt: value.updatedAt,
+        });
+      } catch (error) {
+        if (!isNotFoundError(error) && !(error instanceof SyntaxError)) throw error;
+      }
+    }
+  }
+  return bindings;
+}
+
+async function listJsonFilePaths(path: string): Promise<string[]> {
+  try {
+    return (await readdir(path, { withFileTypes: true }))
+      .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+      .map((entry) => join(path, entry.name))
+      .sort();
+  } catch (error) {
+    if (isNotFoundError(error)) return [];
+    throw error;
+  }
+}
+
+async function listDirectoryNames(path: string): Promise<string[]> {
+  try {
+    return (await readdir(path, { withFileTypes: true }))
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort();
+  } catch (error) {
+    if (isNotFoundError(error)) return [];
+    throw error;
+  }
+}
+
+function assertProjectKey(value: string): void {
+  if (!isProjectKey(value)) {
+    throw new ProjectRegistrationError("invalid", "projectKey is invalid.");
+  }
+}
+
+function isProjectKey(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value !== "." &&
+    value !== ".." &&
+    /^[A-Za-z0-9._-]{1,120}$/.test(value)
+  );
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim() !== "";
+}
+
+function isAbsoluteString(value: unknown): value is string {
+  return isNonEmptyString(value) && isAbsolute(value);
+}
+
+function isWorkspaceKind(value: unknown): value is ProjectWorkspaceKind {
+  return value === "git" || value === "directory";
+}
+
+function isDiscoveryTargetArray(value: unknown): value is ProjectDiscoveryTarget[] {
+  return (
+    Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((item) => item === "claude" || item === "codex")
+  );
+}
+
+function requireRecord(value: unknown): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ProjectRegistrationError("invalid", "Project record must be an object.");
+  }
+  return value as Record<string, unknown>;
+}

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(