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

package/src/runtime-logs/index.ts

@@ -0,0 +1,324 @@
+import { createHash } from "node:crypto";
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { resolveEvoDevPaths } from "../config/paths.ts";
+
+export type EvoDevLogPhase = "started" | "completed" | "failed";
+
+export interface CliLogEntryV1 {
+  version: 1;
+  kind: "cli";
+  timestamp: string;
+  date: string;
+  phase: EvoDevLogPhase;
+  command: string | null;
+  argv: string[];
+  cwd: string | null;
+  pid: number;
+  exitCode: number | null;
+  durationMs: number | null;
+  error: string | null;
+}
+
+export interface TraceLogEntryV1 {
+  version: 1;
+  kind: "trace";
+  timestamp: string;
+  date: string;
+  phase: EvoDevLogPhase;
+  sessionKey: string;
+  target: string;
+  runtime: {
+    surface: "cli" | "plugin";
+    argv: string[];
+    runtimeFile: string | null;
+  };
+  input: {
+    stdinBytes: number | null;
+    payload: unknown;
+  } | null;
+  event: {
+    eventId: string;
+    type: string;
+    summary: string;
+    metadata: unknown;
+    decision: unknown;
+  } | null;
+  result: {
+    enabled: boolean;
+    summary: string;
+    stateWrites: string[];
+    warnings: string[];
+    formattedResponse: string | null;
+    durationMs: number | null;
+  } | null;
+  error: string | null;
+  team: TraceLogTeamContext | null;
+}
+
+export interface TraceLogTeamContext {
+  runId: string;
+  roleId: string;
+  projectKey: string;
+}
+
+export interface CliLogInput {
+  phase: EvoDevLogPhase;
+  argv: string[];
+  timestamp?: Date | string;
+  cwd?: string | null;
+  pid?: number;
+  exitCode?: number | null;
+  durationMs?: number | null;
+  error?: unknown;
+}
+
+export interface TraceLogInput {
+  phase: EvoDevLogPhase;
+  target: string;
+  runtime: TraceLogEntryV1["runtime"];
+  sessionKey?: string;
+  payload?: Record<string, unknown> | null;
+  stdinBytes?: number | null;
+  event?: TraceLogEntryV1["event"] | null;
+  result?: TraceLogEntryV1["result"] | null;
+  timestamp?: Date | string;
+  error?: unknown;
+  team?: TraceLogTeamContext | null;
+}
+
+export interface EvoDevLogPaths {
+  logsDir: string;
+  cliDir: string;
+  cliLogPath: string;
+  traceRootDir: string;
+  traceDateDir: string;
+  traceSessionDir: string | null;
+  traceLogPath: string | null;
+  projectRunDir: string | null;
+  projectRunAgentsDir: string | null;
+  agentLogDir: string | null;
+  agentTraceLogPath: string | null;
+}
+
+const MAX_LOG_STRING_LENGTH = 4096;
+export function createCliLogEntry(input: CliLogInput): CliLogEntryV1 {
+  const timestamp = normalizeTimestamp(input.timestamp);
+  return {
+    version: 1,
+    kind: "cli",
+    timestamp,
+    date: formatLocalDateKey(timestamp),
+    phase: input.phase,
+    command: input.argv[0] ?? null,
+    argv: input.argv.map((arg) => truncateString(arg)),
+    cwd: input.cwd === undefined ? process.cwd() : input.cwd,
+    pid: input.pid ?? process.pid,
+    exitCode: input.exitCode ?? null,
+    durationMs: input.durationMs ?? null,
+    error: input.error === undefined ? null : describeError(input.error),
+  };
+}
+
+export function createTraceLogEntry(input: TraceLogInput): TraceLogEntryV1 {
+  const timestamp = normalizeTimestamp(input.timestamp);
+  const payload = input.payload ?? null;
+  const sessionKey = input.sessionKey ?? resolveTraceSessionKey(payload);
+  return {
+    version: 1,
+    kind: "trace",
+    timestamp,
+    date: formatLocalDateKey(timestamp),
+    phase: input.phase,
+    sessionKey,
+    target: truncateString(input.target),
+    runtime: {
+      surface: input.runtime.surface,
+      argv: input.runtime.argv.map((arg) => truncateString(arg)),
+      runtimeFile:
+        input.runtime.runtimeFile === null ? null : truncateString(input.runtime.runtimeFile),
+    },
+    input:
+      payload === null
+        ? null
+        : {
+            stdinBytes: input.stdinBytes ?? null,
+            payload,
+          },
+    event: input.event === undefined ? null : input.event,
+    result: input.result === undefined ? null : input.result,
+    error: input.error === undefined ? null : describeError(input.error),
+    team:
+      input.team === undefined || input.team === null
+        ? null
+        : {
+            runId: sanitizePathSegment(input.team.runId),
+            roleId: sanitizePathSegment(input.team.roleId),
+            projectKey: sanitizePathSegment(input.team.projectKey),
+          },
+  };
+}
+
+export function resolveEvoDevLogPaths(input: {
+  homeDir: string;
+  timestamp?: Date | string;
+  sessionKey?: string | null;
+  team?: TraceLogTeamContext | null;
+}): EvoDevLogPaths {
+  const paths = resolveEvoDevPaths(input.homeDir);
+  const date = formatLocalDateKey(normalizeTimestamp(input.timestamp));
+  const cliDir = join(paths.logsDir, "cli");
+  const traceRootDir = join(paths.logsDir, "trace");
+  const traceDateDir = join(traceRootDir, date);
+  const traceSessionDir =
+    input.sessionKey === undefined || input.sessionKey === null
+      ? null
+      : join(traceDateDir, sanitizePathSegment(input.sessionKey));
+  const projectRunDir =
+    input.team === undefined || input.team === null
+      ? null
+      : join(
+          paths.logsDir,
+          sanitizePathSegment(input.team.projectKey),
+          sanitizePathSegment(input.team.runId),
+        );
+  const projectRunAgentsDir = projectRunDir === null ? null : join(projectRunDir, "agents");
+  const agentLogDir =
+    projectRunAgentsDir === null || input.team === undefined || input.team === null
+      ? null
+      : join(projectRunAgentsDir, sanitizePathSegment(input.team.roleId));
+
+  return {
+    logsDir: paths.logsDir,
+    cliDir,
+    cliLogPath: join(cliDir, `${date}.log`),
+    traceRootDir,
+    traceDateDir,
+    traceSessionDir,
+    traceLogPath: traceSessionDir === null ? null : join(traceSessionDir, "trace.log"),
+    projectRunDir,
+    projectRunAgentsDir,
+    agentLogDir,
+    agentTraceLogPath: agentLogDir === null ? null : join(agentLogDir, "trace.log"),
+  };
+}
+
+export async function appendCliLogEntry(homeDir: string, entry: CliLogEntryV1): Promise<string> {
+  const path = resolveEvoDevLogPaths({ homeDir, timestamp: entry.timestamp }).cliLogPath;
+  await appendJsonLine(path, entry);
+  return path;
+}
+
+export async function appendTraceLogEntry(
+  homeDir: string,
+  entry: TraceLogEntryV1,
+): Promise<string> {
+  const path = resolveEvoDevLogPaths({
+    homeDir,
+    timestamp: entry.timestamp,
+    sessionKey: entry.sessionKey,
+  }).traceLogPath;
+  if (path === null) throw new Error("Cannot resolve trace log path without a session key.");
+  await appendJsonLine(path, entry);
+  const agentTraceLogPath = resolveEvoDevLogPaths({
+    homeDir,
+    timestamp: entry.timestamp,
+    sessionKey: entry.sessionKey,
+    team: entry.team,
+  }).agentTraceLogPath;
+  if (agentTraceLogPath !== null) {
+    await appendJsonLine(agentTraceLogPath, entry);
+  }
+  return path;
+}
+
+export function resolveTraceTeamContext(input: {
+  homeDir: string;
+  environment?: Record<string, string | undefined>;
+  payload?: Record<string, unknown> | null;
+}): TraceLogTeamContext | null {
+  const environment = input.environment ?? {};
+  const runId = optionalString(environment.EVODEV_TEAM_RUN_ID);
+  const roleId = optionalString(environment.EVODEV_TEAM_ROLE_ID);
+  if (runId === null || roleId === null) return null;
+  const repoRoot =
+    optionalString(environment.EVODEV_TEAM_REPO_ROOT) ??
+    optionalString(input.payload?.cwd) ??
+    input.homeDir;
+  return {
+    runId: sanitizePathSegment(runId),
+    roleId: sanitizePathSegment(roleId),
+    projectKey: resolveProjectLogKey(input.homeDir, repoRoot),
+  };
+}
+
+export function resolveProjectLogKey(homeDir: string, repoRoot: string): string {
+  const trimmedHome = stripTrailingSlash(homeDir);
+  const trimmedRepo = stripTrailingSlash(repoRoot);
+  const relativePath = relative(trimmedHome, trimmedRepo);
+  const source =
+    relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath)
+      ? relativePath
+      : trimmedRepo.replace(/^[/\\]+/, "");
+  return (
+    source
+      .split(/[/\\]+/)
+      .filter(Boolean)
+      .map((part) => sanitizePathSegment(part))
+      .join("-") || "project-local"
+  );
+}
+
+export function resolveTraceSessionKey(payload: unknown): string {
+  const record = isRecord(payload) ? payload : {};
+  const sessionId = optionalString(record.session_id ?? record.sessionId);
+  const cwd = optionalString(record.cwd);
+  const source = sessionId ?? cwd ?? "local";
+  return `session-${createHash("sha256").update(source).digest("hex").slice(0, 16)}`;
+}
+
+async function appendJsonLine(path: string, value: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await appendFile(path, `${JSON.stringify(value)}\n`, "utf8");
+}
+
+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 formatLocalDateKey(timestamp: string): string {
+  const date = new Date(timestamp);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+function truncateString(value: string): string {
+  if (value.length <= MAX_LOG_STRING_LENGTH) return value;
+  return `${value.slice(0, MAX_LOG_STRING_LENGTH)}...[truncated:${value.length - MAX_LOG_STRING_LENGTH}]`;
+}
+
+function sanitizePathSegment(value: string): string {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "session-local";
+}
+
+function stripTrailingSlash(path: string): string {
+  if (path === "/" || /^[A-Za-z]:[\\/]?$/.test(path)) return path;
+  return path.replace(/[/\\]+$/, "");
+}
+
+function optionalString(value: unknown): string | null {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+function describeError(error: unknown): string {
+  if (error instanceof Error) return truncateString(error.message);
+  return truncateString(String(error));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/sync/orchestrator.ts

@@ -25,6 +25,7 @@ export interface SyncOrchestratorOptions {
   assetsRootDir: string;
   pluginRegistry: PluginRegistry;
   dryRun?: boolean;
+  force?: boolean;
   targetPlugins?: PluginId[];
   includeSkills?: boolean;
   includeAgents?: boolean;
@@ -49,6 +50,7 @@ export async function runSync(options: SyncOrchestratorOptions): Promise<SyncRun
     assets,
     plugins,
     dryRun: options.dryRun ?? false,
+    force: options.force ?? false,
     includeSkills: options.includeSkills,
     includeAgents: options.includeAgents,
   });
@@ -77,6 +79,7 @@ export interface BuildSyncPlansInput {
   assets: AssetScanResult;
   plugins: CodeAgentPlugin[];
   dryRun: boolean;
+  force: boolean;
   includeSkills?: boolean;
   includeAgents?: boolean;
 }
@@ -94,6 +97,7 @@ export function buildSyncPlans(input: BuildSyncPlansInput): SyncPlan[] {
     skills: filterAssetsForTarget(skills, plugin.id),
     agents: filterAssetsForTarget(agents, plugin.id),
     dryRun: input.dryRun,
+    force: input.force,
   }));
 }
 
@@ -116,11 +120,13 @@ async function executeSyncPlans(
         targetPlugin: plan.targetPlugin,
         skills: plan.skills,
         dryRun: plan.dryRun,
+        force: plan.force,
       }),
       plugin.syncAgents({
         targetPlugin: plan.targetPlugin,
         agents: plan.agents,
         dryRun: plan.dryRun,
+        force: plan.force,
       }),
     ]);
 

package/src/task/index.ts

@@ -56,7 +56,7 @@ export interface TaskContract {
     requiredVerification: string[];
   };
   verification: {
-    policy: "fail-closed";
+    policy: "advisory";
     commands: VerificationCommandResult[];
     acceptanceResults: VerificationCriterionResult[];
     antiCriteriaResults: VerificationCriterionResult[];
@@ -261,7 +261,7 @@ export function createTaskContract(input: TaskInitInput): TaskContract {
       requiredVerification: uniqueSanitizedIds(input.requiredVerification ?? []),
     },
     verification: {
-      policy: "fail-closed",
+      policy: "advisory",
       commands: [],
       acceptanceResults: [],
       antiCriteriaResults: [],
@@ -353,7 +353,7 @@ export function verifyTaskContract(
           criterion.status,
       })),
       verification: {
-        policy: "fail-closed",
+        policy: "advisory",
         commands,
         acceptanceResults,
         antiCriteriaResults,