@abelxiaoxing/cadence 1.8.4 → 2.0.1

package/src/single-task-draft.ts

@@ -1,142 +0,0 @@
-import { DesignPlanValidationError } from "./design-diagnostics.ts";
-import type {
-  DraftVerification,
-  PlanDraft,
-  PlanTaskInput,
-} from "./plan-draft.ts";
-
-/** Small author input. Evidence, scope and the complete suite remain explicit. */
-export interface SingleTaskDraft {
-  changeId: string;
-  changeContract?: PlanDraft["changeContract"];
-  singleTask: {
-    taskId: string;
-    objective: string;
-    context: PlanTaskInput["context"];
-    roots: string[];
-    read: string[];
-    greenWrite: string[];
-    redWrite?: string[];
-    expectedFailure?: string;
-    verificationMode?: "behavior" | "mechanical" | "refactor";
-    verification: DraftVerification;
-    fullSuite: DraftVerification;
-    impactClosure: PlanTaskInput["impactClosure"];
-    agents: PlanTaskInput["agents"];
-    recovery?: { artifactAttempts: number; repairAttempts: number };
-  };
-}
-
-function invalid(code: string, field = "singleTask"): never {
-  throw new DesignPlanValidationError(code, [{ code, field }]);
-}
-
-function record(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-/** Mechanical expansion only; the ordinary compiler validates all resulting fields. */
-export function expandSingleTaskDraft(value: unknown): unknown {
-  if (!record(value) || !Object.hasOwn(value, "singleTask")) return value;
-  if (
-    Object.keys(value).some(
-      (key) => !["changeId", "changeContract", "singleTask"].includes(key),
-    ) ||
-    !record(value.singleTask)
-  )
-    invalid("single-task-draft-invalid");
-  const input = value.singleTask;
-  const required = [
-    "taskId",
-    "objective",
-    "context",
-    "roots",
-    "read",
-    "greenWrite",
-    "verification",
-    "fullSuite",
-    "impactClosure",
-    "agents",
-  ];
-  const optional = [
-    "redWrite",
-    "expectedFailure",
-    "verificationMode",
-    "recovery",
-  ];
-  if (
-    required.some((key) => !Object.hasOwn(input, key)) ||
-    Object.keys(input).some((key) => ![...required, ...optional].includes(key))
-  )
-    invalid("single-task-draft-invalid");
-  const task = structuredClone(
-    input,
-  ) as unknown as SingleTaskDraft["singleTask"];
-  const mode = task.verificationMode ?? "behavior";
-  if (mode === "behavior" && (!task.redWrite?.length || !task.expectedFailure))
-    invalid("single-task-red-required");
-  if (
-    mode !== "behavior" &&
-    (task.redWrite !== undefined || task.expectedFailure !== undefined)
-  )
-    invalid("single-task-red-unexpected");
-  if (
-    Object.hasOwn(input, "recovery") &&
-    (!record(task.recovery) ||
-      !Object.hasOwn(task.recovery, "artifactAttempts") ||
-      !Object.hasOwn(task.recovery, "repairAttempts") ||
-      Object.keys(task.recovery).some(
-        (key) => !["artifactAttempts", "repairAttempts"].includes(key),
-      ))
-  )
-    invalid("single-task-recovery-invalid");
-  return {
-    changeId: value.changeId,
-    ...(value.changeContract === undefined
-      ? {}
-      : { changeContract: value.changeContract }),
-    tasks: [
-      {
-        taskId: task.taskId,
-        objective: task.objective,
-        context: task.context,
-        roots: task.roots,
-        read: task.read,
-        dependsOn: [],
-        verificationMode: mode,
-        phases: {
-          ...(mode === "behavior"
-            ? {
-                red: {
-                  write: task.redWrite,
-                  delete: [],
-                  verification: {
-                    ...task.verification,
-                    expectedFailure: task.expectedFailure,
-                  },
-                },
-              }
-            : {}),
-          green: {
-            write: task.greenWrite,
-            delete: [],
-            verification: task.verification,
-          },
-        },
-        affectedVerification: task.fullSuite,
-        repairVerification: task.fullSuite,
-        scheduling: { conflicts: [], resources: [] },
-        agents: task.agents,
-        approvedDependencies: [],
-        impactClosure: task.impactClosure,
-      },
-    ],
-    outputs: [],
-    verification: {
-      baseline: { fullSuite: task.fullSuite },
-      change: { fullSuite: task.fullSuite, postApply: task.fullSuite },
-      artifactCorrection: { maxAttempts: task.recovery?.artifactAttempts ?? 2 },
-      repair: { maxAttempts: task.recovery?.repairAttempts ?? 1 },
-    },
-  };
-}

package/src/sqlite-schema.ts

@@ -1,171 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { canonicalJson } from "./canonical.ts";
-
-export class SqliteSchemaError extends Error {
-  readonly code = "storage-schema-invalid";
-  constructor() {
-    super("storage-schema-invalid");
-  }
-}
-
-type Row = Record<string, string | number | null>;
-interface TableContract {
-  columns: Row[];
-  foreignKeys: string[];
-  uniqueKeys: string[];
-  strict: number;
-}
-const contracts = new Map<string, Map<string, TableContract>>();
-const identifier = (name: string): string => `"${name.replaceAll('"', '""')}"`;
-
-export function configureSqlite(
-  database: DatabaseSync,
-  busyTimeoutMs = 5000,
-): void {
-  database.exec("PRAGMA foreign_keys = ON");
-  database.exec("PRAGMA journal_mode = WAL");
-  database.exec("PRAGMA synchronous = FULL");
-  database.exec(
-    `PRAGMA busy_timeout = ${Math.max(1, Math.min(30_000, busyTimeoutMs))}`,
-  );
-}
-
-function describeTable(database: DatabaseSync, table: string): TableContract {
-  const columns = database
-    .prepare(`PRAGMA table_info(${identifier(table)})`)
-    .all() as Row[];
-  const foreignKeys = database
-    .prepare(`PRAGMA foreign_key_list(${identifier(table)})`)
-    .all() as Row[];
-  const indexes = database
-    .prepare(`PRAGMA index_list(${identifier(table)})`)
-    .all() as Row[];
-  const uniqueKeys = indexes
-    .filter((row) => row.unique === 1)
-    .map((row) => {
-      const fields = database
-        .prepare(`PRAGMA index_xinfo(${identifier(String(row.name))})`)
-        .all() as Row[];
-      return canonicalJson({
-        partial: row.partial,
-        fields: fields
-          .filter((field) => field.key === 1)
-          .map(({ name, coll, desc }) => ({ name, coll, desc })),
-      });
-    })
-    .sort();
-  const strict = (
-    database
-      .prepare(
-        "SELECT strict FROM pragma_table_list WHERE schema = 'main' AND name = ?",
-      )
-      .get(table) as Row | undefined
-  )?.strict;
-  return {
-    columns: columns.map(({ name, type, notnull, dflt_value, pk }) => ({
-      name,
-      type,
-      notnull,
-      dflt_value,
-      pk,
-    })),
-    foreignKeys: foreignKeys
-      .map(({ table: target, from, to, on_update, on_delete, match, seq }) =>
-        canonicalJson({ target, from, to, on_update, on_delete, match, seq }),
-      )
-      .sort(),
-    uniqueKeys,
-    strict: Number(strict ?? 0),
-  };
-}
-
-function schemaContract(schema: string): Map<string, TableContract> {
-  const cached = contracts.get(schema);
-  if (cached) return cached;
-  const reference = new DatabaseSync(":memory:");
-  try {
-    reference.exec(schema);
-    const names = reference
-      .prepare(
-        "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'",
-      )
-      .all() as Row[];
-    const contract = new Map(
-      names.map(({ name }) => [
-        String(name),
-        describeTable(reference, String(name)),
-      ]),
-    );
-    contracts.set(schema, contract);
-    return contract;
-  } finally {
-    reference.close();
-  }
-}
-
-/** Check every required column, key, foreign key and STRICT boundary; permit additive columns. */
-export function matchesSqliteSchema(
-  database: DatabaseSync,
-  schema: string,
-): boolean {
-  for (const [table, expected] of schemaContract(schema)) {
-    const actual = describeTable(database, table);
-    if (
-      actual.strict !== expected.strict ||
-      expected.columns.some(
-        (column) =>
-          !actual.columns.some(
-            (candidate) => canonicalJson(candidate) === canonicalJson(column),
-          ),
-      ) ||
-      canonicalJson(actual.foreignKeys) !==
-        canonicalJson(expected.foreignKeys) ||
-      canonicalJson(actual.uniqueKeys) !== canonicalJson(expected.uniqueKeys)
-    )
-      return false;
-  }
-  return true;
-}
-
-/** Serialize creation and the closed, additive migration set across concurrent openers. */
-export function ensureSqliteSchema(
-  database: DatabaseSync,
-  schema: string,
-  additions: Record<string, Record<string, string>> = {},
-): void {
-  database.exec("BEGIN IMMEDIATE");
-  try {
-    const expected = [...schemaContract(schema).keys()];
-    const present = expected.filter((table) =>
-      database
-        .prepare(
-          "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?",
-        )
-        .get(table),
-    );
-    // An absent namespace is a first open; a partially missing namespace is damaged.
-    if (present.length > 0 && present.length !== expected.length)
-      throw new SqliteSchemaError();
-    database.exec(schema);
-    for (const [table, columns] of Object.entries(additions)) {
-      const existing = new Set(
-        describeTable(database, table).columns.map(({ name }) => name),
-      );
-      for (const [column, declaration] of Object.entries(columns)) {
-        if (!existing.has(column))
-          database.exec(
-            `ALTER TABLE ${identifier(table)} ADD COLUMN ${identifier(column)} ${declaration}`,
-          );
-      }
-    }
-    if (!matchesSqliteSchema(database, schema)) throw new SqliteSchemaError();
-    database.exec("COMMIT");
-  } catch (error) {
-    try {
-      database.exec("ROLLBACK");
-    } catch {
-      /* Preserve the original failure. */
-    }
-    throw error;
-  }
-}

package/src/state-root.ts

@@ -1,215 +0,0 @@
-import { createHash } from "node:crypto";
-import { chmodSync, lstatSync, mkdirSync, realpathSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-export const STATE_ROOT_ERROR_CODES = [
-  "consumer-root-unavailable",
-  "invalid-state-base",
-  "state-component-symlink",
-  "state-component-type",
-  "state-root-inside-consumer",
-] as const;
-
-export type StateRootErrorCode = (typeof STATE_ROOT_ERROR_CODES)[number];
-
-export class StateRootError extends Error {
-  readonly code: StateRootErrorCode;
-
-  constructor(code: StateRootErrorCode) {
-    super(code);
-    this.name = "StateRootError";
-    this.code = code;
-  }
-}
-
-export interface StateRootOptions {
-  consumerRoot: string;
-  xdgStateHome?: string;
-  homeDir?: string;
-}
-
-export interface ResolvedStateRoot {
-  consumerRoot: string;
-  consumerRootHash: string;
-  stateBase: string;
-  productRoot: string;
-  rootsDir: string;
-  rootDir: string;
-  databasePath: string;
-  artifactsDir: string;
-  workspacesDir: string;
-  transactionsDir: string;
-}
-
-function isContainedBy(parent: string, candidate: string): boolean {
-  const relative = path.relative(parent, candidate);
-  return (
-    relative === "" ||
-    (!relative.startsWith("..") && !path.isAbsolute(relative))
-  );
-}
-
-function inspectExistingComponents(absolutePath: string): void {
-  const parsed = path.parse(absolutePath);
-  const relativeParts = absolutePath
-    .slice(parsed.root.length)
-    .split(path.sep)
-    .filter(Boolean);
-  let current = parsed.root;
-  for (const part of relativeParts) {
-    current = path.join(current, part);
-    let stat: ReturnType<typeof lstatSync>;
-    try {
-      stat = lstatSync(current);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-      throw error;
-    }
-    if (stat.isSymbolicLink()) {
-      throw new StateRootError("state-component-symlink");
-    }
-    if (!stat.isDirectory() && current !== absolutePath) {
-      throw new StateRootError("state-component-type");
-    }
-  }
-}
-
-function canonicalFuturePath(input: string): string {
-  const absolute = path.resolve(input);
-  inspectExistingComponents(absolute);
-  let cursor = absolute;
-  const missing: string[] = [];
-  for (;;) {
-    try {
-      return path.join(realpathSync.native(cursor), ...missing.reverse());
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-      const parent = path.dirname(cursor);
-      if (parent === cursor) throw error;
-      missing.push(path.basename(cursor));
-      cursor = parent;
-    }
-  }
-}
-
-function requireAbsoluteDirectoryBase(
-  xdgStateHome: string | undefined,
-  homeDir: string,
-): string {
-  if (xdgStateHome && path.isAbsolute(xdgStateHome)) {
-    return canonicalFuturePath(xdgStateHome);
-  }
-  if (!path.isAbsolute(homeDir)) {
-    throw new StateRootError("invalid-state-base");
-  }
-  return canonicalFuturePath(path.join(homeDir, ".local", "state"));
-}
-
-export function resolveStateRoot(options: StateRootOptions): ResolvedStateRoot {
-  let consumerRoot: string;
-  try {
-    consumerRoot = realpathSync.native(path.resolve(options.consumerRoot));
-    if (!lstatSync(consumerRoot).isDirectory()) {
-      throw new StateRootError("consumer-root-unavailable");
-    }
-  } catch (error) {
-    if (error instanceof StateRootError) throw error;
-    throw new StateRootError("consumer-root-unavailable");
-  }
-
-  const stateBase = requireAbsoluteDirectoryBase(
-    options.xdgStateHome,
-    options.homeDir ?? os.homedir(),
-  );
-  const consumerRootHash = createHash("sha256")
-    .update(consumerRoot)
-    .digest("hex");
-  const productRoot = canonicalFuturePath(path.join(stateBase, "abel-cadence"));
-  const rootsDir = canonicalFuturePath(path.join(productRoot, "roots"));
-  const rootDir = canonicalFuturePath(path.join(rootsDir, consumerRootHash));
-
-  if (isContainedBy(consumerRoot, rootDir)) {
-    throw new StateRootError("state-root-inside-consumer");
-  }
-
-  return {
-    consumerRoot,
-    consumerRootHash,
-    stateBase,
-    productRoot,
-    rootsDir,
-    rootDir,
-    databasePath: path.join(rootDir, "control.sqlite3"),
-    artifactsDir: path.join(rootDir, "artifacts"),
-    workspacesDir: path.join(rootDir, "workspaces"),
-    transactionsDir: path.join(rootDir, "transactions"),
-  };
-}
-
-function ensureDirectory(directory: string): void {
-  let stat: ReturnType<typeof lstatSync>;
-  try {
-    stat = lstatSync(directory);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-    const parent = path.dirname(directory);
-    if (parent !== directory) ensureDirectory(parent);
-    mkdirSync(directory, { mode: 0o700 });
-    chmodSync(directory, 0o700);
-    return;
-  }
-  if (stat.isSymbolicLink()) {
-    throw new StateRootError("state-component-symlink");
-  }
-  if (!stat.isDirectory()) {
-    throw new StateRootError("state-component-type");
-  }
-}
-
-export function prepareStateRoot(
-  resolved: ResolvedStateRoot,
-): ResolvedStateRoot {
-  const checked = resolveStateRoot({
-    consumerRoot: resolved.consumerRoot,
-    xdgStateHome: resolved.stateBase,
-    homeDir: path.dirname(resolved.stateBase),
-  });
-  if (
-    checked.consumerRootHash !== resolved.consumerRootHash ||
-    checked.rootDir !== resolved.rootDir
-  ) {
-    throw new StateRootError("invalid-state-base");
-  }
-
-  ensureDirectory(resolved.stateBase);
-  for (const directory of [
-    resolved.productRoot,
-    resolved.rootsDir,
-    resolved.rootDir,
-    resolved.artifactsDir,
-    resolved.workspacesDir,
-    resolved.transactionsDir,
-  ]) {
-    ensureDirectory(directory);
-    chmodSync(directory, 0o700);
-  }
-
-  try {
-    const database = lstatSync(resolved.databasePath);
-    if (database.isSymbolicLink()) {
-      throw new StateRootError("state-component-symlink");
-    }
-    if (!database.isFile()) {
-      throw new StateRootError("state-component-type");
-    }
-  } catch (error) {
-    if (
-      error instanceof StateRootError ||
-      (error as NodeJS.ErrnoException).code !== "ENOENT"
-    ) {
-      throw error;
-    }
-  }
-  return { ...resolved };
-}