@abelxiaoxing/cadence 1.0.14 → 1.1.1

package/src/scheduler.ts

@@ -1,384 +0,0 @@
-// Minimal in-memory scheduler for the private orchestration kernel.
-// FIFO DAG-ready admission with one global active limit, declared-set
-// declared serialization, batch cancellation, and at most one mechanical redispatch.
-import { LIMITS, type RequestEnvelope } from "./contracts.ts";
-
-export type TerminalStatus = "succeeded" | "failed" | "cancelled";
-
-export interface ScheduledRequest {
-  request: RequestEnvelope;
-  prerequisites: string[];
-  mechanicalRedispatch?: boolean;
-}
-
-export interface ScheduledOutcome<T = unknown> {
-  id: string;
-  status: TerminalStatus;
-  attempts: number;
-  value?: T;
-  error?: string;
-}
-
-export interface BatchHandle<T = unknown> {
-  batchId: string;
-  result(id: string): Promise<ScheduledOutcome<T>>;
-  done: Promise<ScheduledOutcome<T>[]>;
-}
-
-export interface SchedulerOptions<T = unknown> {
-  limit: number;
-  execute(
-    request: RequestEnvelope,
-    signal: AbortSignal,
-    attempt: number,
-  ): Promise<T>;
-}
-
-export interface ConflictDeclaration {
-  taskId: string;
-  requestId?: string;
-  read: string[];
-  write: string[];
-  conflicts: string[];
-  resources: string[];
-  verificationLocks: string[];
-}
-
-type EntryState = "queued" | "running" | TerminalStatus;
-
-interface Entry<T> {
-  request: RequestEnvelope;
-  prerequisites: string[];
-  mechanicalRedispatch: boolean;
-  state: EntryState;
-  attempts: number;
-  cancelRequested: boolean;
-  cancelReason: unknown;
-  controller: AbortController | null;
-  resolve(outcome: ScheduledOutcome<T>): void;
-  promise: Promise<ScheduledOutcome<T>>;
-}
-
-function intersects(left: string[], right: string[]): boolean {
-  return left.some((path) => right.includes(path));
-}
-
-function pathsOverlap(left: string, right: string): boolean {
-  return (
-    left === "." ||
-    right === "." ||
-    left === right ||
-    left.startsWith(`${right}/`) ||
-    right.startsWith(`${left}/`)
-  );
-}
-
-function pathSetsOverlap(left: string[], right: string[]): boolean {
-  return left.some((a) => right.some((b) => pathsOverlap(a, b)));
-}
-
-function conflictEdgeMatches(
-  conflicts: string[],
-  other: ConflictDeclaration,
-): boolean {
-  return conflicts.some(
-    (edge) =>
-      edge === other.taskId ||
-      edge === other.requestId ||
-      other.read.some((path) => pathsOverlap(edge, path)) ||
-      other.write.some((path) => pathsOverlap(edge, path)),
-  );
-}
-
-function requestConflictOf(request: RequestEnvelope): ConflictDeclaration {
-  return {
-    taskId: request.taskId ?? request.id,
-    requestId: request.id,
-    read: request.declared.read,
-    write: request.declared.write,
-    conflicts: request.declared.conflicts,
-    resources: request.declared.resources,
-    verificationLocks: request.declared.verificationLock
-      ? [request.declared.verificationLock]
-      : [],
-  };
-}
-
-/** True when two pure declarations cannot be active at the same time. */
-export function declarationsConflict(
-  left: ConflictDeclaration,
-  right: ConflictDeclaration,
-): boolean {
-  const a = left;
-  const b = right;
-  if (a.taskId === b.taskId) return true;
-  if (pathSetsOverlap(a.write, b.write)) return true;
-  if (pathSetsOverlap(a.write, b.read) || pathSetsOverlap(a.read, b.write)) {
-    return true;
-  }
-  if (conflictEdgeMatches(a.conflicts, right)) return true;
-  if (conflictEdgeMatches(b.conflicts, left)) return true;
-  if (intersects(a.resources, b.resources)) return true;
-  return intersects(a.verificationLocks, b.verificationLocks);
-}
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-class Batch<T> {
-  readonly entries: Entry<T>[] = [];
-  readonly byId = new Map<string, Entry<T>>();
-
-  constructor(
-    readonly batchId: string,
-    requests: ScheduledRequest[],
-  ) {
-    for (const scheduled of requests) {
-      let resolve: (outcome: ScheduledOutcome<T>) => void = () => {};
-      const promise = new Promise<ScheduledOutcome<T>>((accept) => {
-        resolve = accept;
-      });
-      const entry: Entry<T> = {
-        request: scheduled.request,
-        prerequisites: [...scheduled.prerequisites],
-        mechanicalRedispatch: scheduled.mechanicalRedispatch === true,
-        state: "queued",
-        attempts: 0,
-        cancelRequested: false,
-        cancelReason: undefined,
-        controller: null,
-        resolve,
-        promise,
-      };
-      this.entries.push(entry);
-      this.byId.set(entry.request.id, entry);
-    }
-  }
-}
-
-export class Scheduler<T> {
-  private readonly limit: number;
-  private readonly execute: SchedulerOptions<T>["execute"];
-  private readonly batches: Batch<T>[] = [];
-  private readonly active = new Set<Entry<T>>();
-
-  constructor(options: SchedulerOptions<T>) {
-    this.limit = Math.max(
-      1,
-      Math.min(options.limit, LIMITS.maxActiveChildSessions),
-    );
-    this.execute = options.execute;
-  }
-
-  schedule(batchId: string, requests: ScheduledRequest[]): BatchHandle<T> {
-    if (requests.length > LIMITS.maxRequestsPerBatch) {
-      throw new Error(
-        `batch ${batchId} exceeds ${LIMITS.maxRequestsPerBatch} requests`,
-      );
-    }
-    const batch = new Batch<T>(batchId, requests);
-    this.batches.push(batch);
-    for (const entry of batch.entries) {
-      const missing = entry.prerequisites.find((id) => !batch.byId.has(id));
-      if (missing !== undefined) {
-        this.settle(batch, entry, {
-          id: entry.request.id,
-          status: "cancelled",
-          attempts: 0,
-          error: `unknown prerequisite: ${missing}`,
-        });
-      }
-    }
-    this.pump();
-    const done = Promise.all(batch.entries.map((entry) => entry.promise));
-    void done.then(() => this.removeBatch(batch));
-    return {
-      batchId,
-      result: (id: string) => {
-        const entry = batch.byId.get(id);
-        if (!entry) throw new Error(`unknown scheduled request: ${id}`);
-        return entry.promise;
-      },
-      done,
-    };
-  }
-
-  private removeBatch(batch: Batch<T>): void {
-    const index = this.batches.indexOf(batch);
-    if (index >= 0) this.batches.splice(index, 1);
-  }
-
-  cancel(
-    batchId: string,
-    reason: unknown = new Error("batch cancelled"),
-  ): void {
-    const batch = this.batches.find(
-      (candidate) => candidate.batchId === batchId,
-    );
-    if (batch) this.cancelBatch(batch, reason);
-  }
-
-  async cancelAll(
-    reason: unknown = new Error("batch cancelled"),
-  ): Promise<void> {
-    const batches = [...this.batches];
-    for (const batch of batches) this.requestCancellation(batch, reason);
-    for (const batch of batches) this.settleQueuedCancellation(batch);
-    await Promise.all(
-      batches.flatMap((batch) => batch.entries.map((entry) => entry.promise)),
-    );
-  }
-
-  private cancelBatch(batch: Batch<T>, reason: unknown): void {
-    this.requestCancellation(batch, reason);
-    this.settleQueuedCancellation(batch);
-  }
-
-  private requestCancellation(batch: Batch<T>, reason: unknown): void {
-    for (const entry of batch.entries) {
-      if (entry.state !== "queued" && entry.state !== "running") continue;
-      if (!entry.cancelRequested) entry.cancelReason = reason;
-      entry.cancelRequested = true;
-      if (entry.state === "running") entry.controller?.abort(reason);
-    }
-  }
-
-  private settleQueuedCancellation(batch: Batch<T>): void {
-    for (const entry of batch.entries) {
-      if (entry.state === "queued") {
-        this.settle(batch, entry, this.cancelOutcome(entry));
-      }
-    }
-    this.pump();
-  }
-
-  private pump(): void {
-    for (const batch of this.batches) {
-      for (const entry of batch.entries) {
-        if (this.active.size >= this.limit) return;
-        if (entry.state !== "queued" || entry.cancelRequested) continue;
-        if (!this.prerequisitesSucceeded(batch, entry)) continue;
-        if (this.hasActiveConflict(entry)) continue;
-        this.start(batch, entry);
-      }
-    }
-  }
-
-  private prerequisitesSucceeded(batch: Batch<T>, entry: Entry<T>): boolean {
-    return entry.prerequisites.every(
-      (id) => batch.byId.get(id)?.state === "succeeded",
-    );
-  }
-
-  private hasActiveConflict(entry: Entry<T>): boolean {
-    for (const activeEntry of this.active) {
-      if (
-        declarationsConflict(
-          requestConflictOf(entry.request),
-          requestConflictOf(activeEntry.request),
-        )
-      ) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  private start(batch: Batch<T>, entry: Entry<T>): void {
-    // Guarded start: a cancelled or settled queued closure never runs later.
-    if (entry.state !== "queued" || entry.cancelRequested) return;
-    entry.state = "running";
-    entry.attempts += 1;
-    entry.controller = new AbortController();
-    this.active.add(entry);
-    const attempt = entry.attempts;
-    this.execute(entry.request, entry.controller.signal, attempt).then(
-      (value) => {
-        if (entry.cancelRequested) {
-          this.settleCancelled(batch, entry);
-          return;
-        }
-        this.settle(batch, entry, {
-          id: entry.request.id,
-          status: "succeeded",
-          attempts: entry.attempts,
-          value,
-        });
-      },
-      (error) => {
-        if (entry.cancelRequested) {
-          this.settleCancelled(batch, entry);
-          return;
-        }
-        if (entry.mechanicalRedispatch && attempt === 1) {
-          this.redispatch(batch, entry);
-          return;
-        }
-        this.settle(batch, entry, {
-          id: entry.request.id,
-          status: "failed",
-          attempts: entry.attempts,
-          error: errorMessage(error),
-        });
-      },
-    );
-  }
-
-  private redispatch(batch: Batch<T>, entry: Entry<T>): void {
-    // One identical mechanical redispatch in the retained active slot; the
-    // attempt becomes 2 and a further failure settles, so no third attempt.
-    entry.state = "queued";
-    entry.controller = null;
-    this.start(batch, entry);
-  }
-
-  private settleCancelled(batch: Batch<T>, entry: Entry<T>): void {
-    this.settle(batch, entry, this.cancelOutcome(entry));
-  }
-
-  private cancelOutcome(entry: Entry<T>): ScheduledOutcome<T> {
-    return {
-      id: entry.request.id,
-      status: "cancelled",
-      attempts: entry.attempts,
-      error: errorMessage(entry.cancelReason ?? new Error("batch cancelled")),
-    };
-  }
-
-  private settle(
-    batch: Batch<T>,
-    entry: Entry<T>,
-    outcome: ScheduledOutcome<T>,
-  ): void {
-    // Every scheduled request reaches exactly one terminal state.
-    if (entry.state !== "queued" && entry.state !== "running") return;
-    entry.state = outcome.status;
-    this.active.delete(entry);
-    entry.controller = null;
-    entry.resolve(outcome);
-    if (outcome.status !== "succeeded") {
-      this.blockDependents(batch, entry.request.id, outcome.status);
-    }
-    this.pump();
-  }
-
-  private blockDependents(
-    batch: Batch<T>,
-    prerequisiteId: string,
-    status: TerminalStatus,
-  ): void {
-    // A dependent can never start after a prerequisite failure or cancel;
-    // independent siblings keep their own outcomes.
-    for (const dependent of batch.entries) {
-      if (dependent.state !== "queued") continue;
-      if (!dependent.prerequisites.includes(prerequisiteId)) continue;
-      this.settle(batch, dependent, {
-        id: dependent.request.id,
-        status: "cancelled",
-        attempts: dependent.attempts,
-        error: `blocked: prerequisite ${prerequisiteId} ${status}`,
-      });
-    }
-  }
-}

package/src/subagent-endpoint.ts

@@ -1,158 +0,0 @@
-// Per-role subagent endpoint resolution from the cadence env file.
-// Three-tier whole-layer semantics: role layer, global layer, inherited.
-
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import path from "node:path";
-import { parseEnvFile } from "../skills/_shared/load-config.mjs";
-import { ROLES } from "./contracts.ts";
-
-export type SubagentRole = (typeof ROLES)[number];
-
-export type SubagentDialect =
-  | "openai-completions"
-  | "openai-responses"
-  | "anthropic-messages";
-
-const LAYER_FIELDS = [
-  "API_URL",
-  "API_KEY",
-  "MODEL",
-  "API",
-  "CONTEXT_WINDOW",
-  "MAX_TOKENS",
-] as const;
-type LayerField = (typeof LAYER_FIELDS)[number];
-type Layer = Partial<Record<LayerField, string>>;
-
-const GLOBAL_PREFIX = "SUBAGENT_";
-const DEFAULT_DIALECT: SubagentDialect = "openai-completions";
-const DIALECTS: readonly SubagentDialect[] = [
-  "openai-completions",
-  "openai-responses",
-  "anthropic-messages",
-];
-
-export const DEFAULT_CONTEXT_WINDOW = 256000;
-export const DEFAULT_MAX_TOKENS = 128000;
-
-export interface SubagentEndpoint {
-  readonly url: string;
-  readonly apiKey?: string;
-  readonly model: string;
-  readonly dialect: SubagentDialect;
-  readonly contextWindow: number;
-  readonly maxTokens: number;
-}
-
-export type SubagentEndpointResolution =
-  | { kind: "inherited" }
-  | { kind: "custom"; endpoint: Readonly<SubagentEndpoint> }
-  | { kind: "invalid"; keys: string[]; file?: string };
-
-export function describeInvalidSubagentEndpoint(
-  resolution: Extract<SubagentEndpointResolution, { kind: "invalid" }>,
-): string {
-  return resolution.keys.length > 0
-    ? `invalid subagent endpoint configuration keys: ${resolution.keys.join(", ")}`
-    : `invalid subagent endpoint configuration file: ${resolution.file ?? "unknown"}`;
-}
-
-function layerOf(values: Record<string, string>, prefix: string): Layer {
-  const layer: Layer = {};
-  for (const field of LAYER_FIELDS) {
-    const value = values[prefix + field];
-    if (value !== undefined && value !== "") layer[field] = value;
-  }
-  return layer;
-}
-
-function isCommitted(layer: Layer): boolean {
-  return LAYER_FIELDS.some((field) => layer[field] !== undefined);
-}
-
-function isHttpUrl(value: string): boolean {
-  try {
-    const parsed = new URL(value);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-
-function isPositiveInteger(value: string): boolean {
-  const number = Number(value);
-  return /^[0-9]+$/.test(value) && Number.isSafeInteger(number) && number > 0;
-}
-
-function offendingKeys(prefix: string, layer: Layer): string[] {
-  const keys: string[] = [];
-  if (layer.API_URL === undefined || !isHttpUrl(layer.API_URL))
-    keys.push(`${prefix}API_URL`);
-  if (layer.MODEL === undefined) keys.push(`${prefix}MODEL`);
-  if (
-    layer.API !== undefined &&
-    !DIALECTS.includes(layer.API as SubagentDialect)
-  )
-    keys.push(`${prefix}API`);
-  if (
-    layer.CONTEXT_WINDOW !== undefined &&
-    !isPositiveInteger(layer.CONTEXT_WINDOW)
-  )
-    keys.push(`${prefix}CONTEXT_WINDOW`);
-  if (layer.MAX_TOKENS !== undefined && !isPositiveInteger(layer.MAX_TOKENS))
-    keys.push(`${prefix}MAX_TOKENS`);
-  return keys;
-}
-
-function selectEnvFile(cwd: string, home: string): string | null {
-  const projectPath = path.join(cwd, ".pi", "cadence", ".env");
-  if (existsSync(projectPath)) return projectPath;
-  const userPath = path.join(home, ".pi", "agent", "cadence", ".env");
-  if (existsSync(userPath)) return userPath;
-  return null;
-}
-
-export function resolveSubagentEndpoint(
-  role: string,
-  options?: { cwd?: string; home?: string },
-): SubagentEndpointResolution {
-  if (!(ROLES as readonly string[]).includes(role))
-    return { kind: "invalid", keys: ["SUBAGENT_ROLE"] };
-  const cwd = options?.cwd ?? process.cwd();
-  const home = options?.home ?? homedir();
-  const file = selectEnvFile(cwd, home);
-  if (!file) return { kind: "inherited" };
-  let values: Record<string, string>;
-  try {
-    values = parseEnvFile(readFileSync(file, "utf8"));
-  } catch {
-    return { kind: "invalid", keys: [], file };
-  }
-  const rolePrefix = `SUBAGENT_${role.toUpperCase().replaceAll("-", "_")}_`;
-  const roleLayer = layerOf(values, rolePrefix);
-  let layer: Layer | undefined = isCommitted(roleLayer) ? roleLayer : undefined;
-  if (!layer) {
-    const globalLayer = layerOf(values, GLOBAL_PREFIX);
-    if (isCommitted(globalLayer)) layer = globalLayer;
-  }
-  if (!layer) return { kind: "inherited" };
-  const prefix = layer === roleLayer ? rolePrefix : GLOBAL_PREFIX;
-  const keys = offendingKeys(prefix, layer);
-  if (keys.length > 0) return { kind: "invalid", keys, file };
-  const endpoint: Readonly<SubagentEndpoint> = Object.freeze({
-    url: layer.API_URL ?? "",
-    ...(layer.API_KEY === undefined ? {} : { apiKey: layer.API_KEY }),
-    model: layer.MODEL ?? "",
-    dialect: (layer.API as SubagentDialect | undefined) ?? DEFAULT_DIALECT,
-    contextWindow:
-      layer.CONTEXT_WINDOW === undefined
-        ? DEFAULT_CONTEXT_WINDOW
-        : Number(layer.CONTEXT_WINDOW),
-    maxTokens:
-      layer.MAX_TOKENS === undefined
-        ? DEFAULT_MAX_TOKENS
-        : Number(layer.MAX_TOKENS),
-  });
-  return { kind: "custom", endpoint };
-}