@aipper/aiws 0.0.29 → 0.0.30

package/src/fs.js

@@ -1,91 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-/**
- * @param {string} p
- */
-export async function pathExists(p) {
-  try {
-    await fs.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * @param {string} p
- */
-export async function ensureDir(p) {
-  await fs.mkdir(p, { recursive: true });
-}
-
-/**
- * @param {string} p
- */
-export async function readText(p) {
-  return await fs.readFile(p, "utf8");
-}
-
-/**
- * @param {string} p
- * @param {string} content
- */
-export async function writeText(p, content) {
-  await ensureDir(path.dirname(p));
-  await fs.writeFile(p, content, "utf8");
-}
-
-/**
- * @param {string} src
- * @param {string} dest
- * @param {{ chmod?: number }=} options
- */
-export async function copyFile(src, dest, options) {
-  await ensureDir(path.dirname(dest));
-  await fs.copyFile(src, dest);
-  if (typeof options?.chmod === "number") {
-    await fs.chmod(dest, options.chmod);
-    return;
-  }
-  try {
-    const st = await fs.stat(src);
-    await fs.chmod(dest, st.mode & 0o777);
-  } catch {
-    // ignore chmod errors (e.g. on certain filesystems)
-  }
-}
-
-/**
- * Very small glob support for patterns ending with `/**`.
- *
- * @param {string} rootDir
- * @param {string} prefixDir
- * @returns {Promise<string[]>} paths relative to rootDir
- */
-export async function listFilesRecursive(rootDir, prefixDir) {
-  /** @type {string[]} */
-  const out = [];
-  const start = path.join(rootDir, prefixDir);
-  if (!(await pathExists(start))) return out;
-
-  /** @type {Array<{ abs: string, rel: string }>} */
-  const stack = [{ abs: start, rel: prefixDir }];
-  while (stack.length > 0) {
-    const cur = stack.pop();
-    if (!cur) break;
-    const entries = await fs.readdir(cur.abs, { withFileTypes: true });
-    for (const ent of entries) {
-      const abs = path.join(cur.abs, ent.name);
-      const rel = path.posix.join(cur.rel.replaceAll(path.sep, "/"), ent.name);
-      if (ent.isDirectory()) {
-        stack.push({ abs, rel });
-      } else if (ent.isFile()) {
-        out.push(rel);
-      }
-    }
-  }
-  out.sort();
-  return out;
-}
-

package/src/governance.js

@@ -1,159 +0,0 @@
-import { UserError } from "./errors.js";
-import { loadWorkflowGovernanceRules } from "./spec.js";
-
-/**
- * @param {any} status
- */
-export function effectiveReviewCount(status) {
-  return Number(status?.reviewSignals?.effectiveCount ?? status?.collaboration?.counts?.review ?? 0);
-}
-
-/**
- * @param {any} status
- * @param {any} [governance]
- */
-function collectGovernanceSignals(status, governance) {
-  const git = status?.git && typeof status.git === "object" ? status.git : {};
-  const lifecycle = status?.lifecycle && typeof status.lifecycle === "object" ? status.lifecycle : {};
-  const repo = status?.repo && typeof status.repo === "object" ? status.repo : {};
-  const gov = governance && typeof governance === "object" ? governance : status?.governance && typeof status.governance === "object" ? status.governance : {};
-  const reviewGates = status?.reviewGates && typeof status.reviewGates === "object" ? status.reviewGates : {};
-  const reviewGateSummary = reviewGates?.summary && typeof reviewGates.summary === "object" ? reviewGates.summary : {};
-  const reviewEffectiveCount = effectiveReviewCount(status);
-  const specReviewReady = reviewGates?.specReview?.ready === true || (!reviewGates.specReview && reviewEffectiveCount > 0);
-  const qualityReviewReady = reviewGates?.qualityReview?.ready === true || (!reviewGates.qualityReview && reviewEffectiveCount > 0);
-  const verifyBeforeCompleteReady = reviewGates?.verifyBeforeComplete?.ready === true;
-  const validateStampReady = reviewGates?.validateStamp?.ready === true;
-
-  return {
-    change_id: String(status?.changeId || ""),
-    blockers_strict_count: Array.isArray(status?.blockersStrict) ? status.blockersStrict.length : 0,
-    finish_resume_required: status?.terminatedReuse?.kind === "finished_unarchived",
-    tasks_unchecked: Number(status?.tasks?.unchecked || 0),
-    review_effective_count: reviewEffectiveCount,
-    evidence_persistent_count: Number(status?.evidence?.counts?.persistent || 0),
-    git_total: Number(git.total || 0),
-    git_staged: Number(git.staged || 0),
-    git_conflicted: Number(git.conflicted || 0),
-    lifecycle_evidence_runs: Number(lifecycle.evidenceRuns || 0),
-    finish_cleanup_pending_reason: String(lifecycle.finishCleanupPendingReason || ""),
-    finish_state: String(lifecycle.finishState || ""),
-    finish_state_reason: String(lifecycle.finishStateReason || ""),
-    repo_submodules: Number(repo.submodules || 0),
-    spec_review_ready: specReviewReady,
-    quality_review_ready: qualityReviewReady,
-    verify_before_complete_ready: verifyBeforeCompleteReady,
-    validate_stamp_ready: validateStampReady,
-    spec_review_status: String(reviewGates?.specReview?.status || (specReviewReady ? "ready" : "missing")),
-    quality_review_status: String(reviewGates?.qualityReview?.status || (qualityReviewReady ? "ready" : "missing")),
-    verify_before_complete_status: String(
-      reviewGates?.verifyBeforeComplete?.status || (verifyBeforeCompleteReady ? "ready" : "missing"),
-    ),
-    validate_stamp_status: String(reviewGates?.validateStamp?.status || (validateStampReady ? "ready" : "missing")),
-    dual_review_missing_count: Number(reviewGateSummary?.dualReviewMissingCount || 0),
-    finish_gate_missing_count: Number(reviewGateSummary?.finishGateMissingCount || 0),
-    governance_current_stage: String(gov.currentStage || ""),
-    governance_recommended_stage: String(gov.recommendedStage || ""),
-    governance_rule_id: String(gov.ruleId || ""),
-  };
-}
-
-/**
- * @param {string} template
- * @param {Record<string, string | number | boolean>} signals
- */
-function renderTemplate(template, signals) {
-  return String(template || "").replace(/\{([a-z0-9_]+)\}/gi, (_, key) => String(signals[key] ?? ""));
-}
-
-/**
- * @param {unknown} actual
- * @param {any} condition
- */
-function matchesLeafCondition(actual, condition) {
-  if (Object.prototype.hasOwnProperty.call(condition, "eq") && actual !== condition.eq) return false;
-  if (Object.prototype.hasOwnProperty.call(condition, "ne") && actual === condition.ne) return false;
-  if (Object.prototype.hasOwnProperty.call(condition, "gt") && !(Number(actual) > Number(condition.gt))) return false;
-  if (Object.prototype.hasOwnProperty.call(condition, "gte") && !(Number(actual) >= Number(condition.gte))) return false;
-  if (Object.prototype.hasOwnProperty.call(condition, "lt") && !(Number(actual) < Number(condition.lt))) return false;
-  if (Object.prototype.hasOwnProperty.call(condition, "lte") && !(Number(actual) <= Number(condition.lte))) return false;
-  if (Array.isArray(condition?.in) && !condition.in.includes(actual)) return false;
-  if (Array.isArray(condition?.notIn) && condition.notIn.includes(actual)) return false;
-  if (condition?.truthy === true && !actual) return false;
-  if (condition?.falsy === true && !!actual) return false;
-  return true;
-}
-
-/**
- * @param {any} when
- * @param {Record<string, string | number | boolean>} signals
- */
-function matchesCondition(when, signals) {
-  if (!when || (typeof when === "object" && Object.keys(when).length === 0)) return true;
-  if (Array.isArray(when?.all)) return when.all.every((item) => matchesCondition(item, signals));
-  if (Array.isArray(when?.any)) return when.any.some((item) => matchesCondition(item, signals));
-  if (when?.not) return !matchesCondition(when.not, signals);
-  if (typeof when?.signal === "string") {
-    return matchesLeafCondition(signals[when.signal], when);
-  }
-  return false;
-}
-
-/**
- * @param {string[]} lines
- */
-function uniqueLines(lines) {
-  const seen = new Set();
-  /** @type {string[]} */
-  const out = [];
-  for (const raw of lines || []) {
-    const line = String(raw || "").trim();
-    if (!line || seen.has(line)) continue;
-    seen.add(line);
-    out.push(line);
-  }
-  return out;
-}
-
-/**
- * @param {any} status
- */
-export async function inferChangeGovernance(status) {
-  const spec = await loadWorkflowGovernanceRules();
-  const signals = collectGovernanceSignals(status);
-  const matched = spec.governanceRules.find((rule) => matchesCondition(rule?.when, signals));
-  if (!matched) {
-    throw new UserError("Failed to infer workflow governance from spec rules.", {
-      details: JSON.stringify({ source: spec.source, signals }, null, 2),
-    });
-  }
-  return {
-    phase: String(status?.phase || ""),
-    currentStage: String(matched.currentStage || ""),
-    recommendedStage: String(matched.recommendedStage || matched.currentStage || ""),
-    rationale: renderTemplate(String(matched.rationale || ""), signals),
-    ruleId: String(matched.id || ""),
-    source: spec.source,
-  };
-}
-
-/**
- * @param {any} status
- */
-export async function governanceGuidanceLines(status) {
-  const spec = await loadWorkflowGovernanceRules();
-  const governance = status?.governance && typeof status.governance === "object" ? status.governance : await inferChangeGovernance(status);
-  const signals = collectGovernanceSignals(status, governance);
-  /** @type {string[]} */
-  const lines = [];
-
-  for (const rule of spec.guidanceRules) {
-    if (!matchesCondition(rule?.when, signals)) continue;
-    const entries = Array.isArray(rule?.lines) ? rule.lines : [];
-    for (const entry of entries) lines.push(renderTemplate(String(entry || ""), signals));
-  }
-
-  const deduped = uniqueLines(lines);
-  if (deduped.length > 0) return deduped;
-  return ["按阶段契约继续推进当前 change"];
-}

package/src/hash.js

@@ -1,25 +0,0 @@
-import crypto from "node:crypto";
-import { readText } from "./fs.js";
-
-/**
- * @param {string} s
- */
-export function normalizeNewlines(s) {
-  return s.replaceAll("\r\n", "\n");
-}
-
-/**
- * @param {string} text
- */
-export function sha256Text(text) {
-  return crypto.createHash("sha256").update(text, "utf8").digest("hex");
-}
-
-/**
- * @param {string} filePath
- */
-export async function sha256FileText(filePath) {
-  const content = normalizeNewlines(await readText(filePath));
-  return sha256Text(content);
-}
-

package/src/json-schema-lite.js

@@ -1,164 +0,0 @@
-import { UserError } from "./errors.js";
-
-function isPlainObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-function joinPath(base, segment) {
-  if (!base || base === "$") return `$${segment}`;
-  return `${base}${segment}`;
-}
-
-function resolvePointer(rootSchema, ref) {
-  if (typeof ref !== "string" || !ref.startsWith("#/")) {
-    throw new UserError("Unsupported schema $ref.", { details: String(ref || "") });
-  }
-  const parts = ref
-    .slice(2)
-    .split("/")
-    .map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
-  let cur = rootSchema;
-  for (const part of parts) {
-    if (!isPlainObject(cur) && !Array.isArray(cur)) return undefined;
-    cur = cur[part];
-  }
-  return cur;
-}
-
-function typeMatches(value, type) {
-  switch (type) {
-    case "object":
-      return isPlainObject(value);
-    case "array":
-      return Array.isArray(value);
-    case "string":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number" && Number.isFinite(value);
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "boolean":
-      return typeof value === "boolean";
-    case "null":
-      return value === null;
-    default:
-      return true;
-  }
-}
-
-/**
- * @param {any} value
- * @param {any} schema
- * @param {any} rootSchema
- * @param {string} curPath
- * @param {string[]} errors
- */
-function validateNode(value, schema, rootSchema, curPath, errors) {
-  if (!isPlainObject(schema)) return;
-
-  if (schema.$ref) {
-    const target = resolvePointer(rootSchema, schema.$ref);
-    if (!target) {
-      errors.push(`${curPath}: unresolved $ref ${schema.$ref}`);
-      return;
-    }
-    validateNode(value, target, rootSchema, curPath, errors);
-    return;
-  }
-
-  if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
-    const matched = schema.anyOf.some((candidate) => {
-      const branchErrors = [];
-      validateNode(value, candidate, rootSchema, curPath, branchErrors);
-      return branchErrors.length === 0;
-    });
-    if (!matched) errors.push(`${curPath}: does not match anyOf`);
-  }
-
-  if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-    for (const candidate of schema.allOf) validateNode(value, candidate, rootSchema, curPath, errors);
-  }
-
-  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-    let matches = 0;
-    for (const candidate of schema.oneOf) {
-      const branchErrors = [];
-      validateNode(value, candidate, rootSchema, curPath, branchErrors);
-      if (branchErrors.length === 0) matches += 1;
-    }
-    if (matches !== 1) errors.push(`${curPath}: does not match exactly one schema`);
-  }
-
-  if (schema.type && !typeMatches(value, schema.type)) {
-    errors.push(`${curPath}: expected ${schema.type}`);
-    return;
-  }
-
-  if (Object.prototype.hasOwnProperty.call(schema, "const") && value !== schema.const) {
-    errors.push(`${curPath}: expected const ${JSON.stringify(schema.const)}`);
-  }
-
-  if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
-    errors.push(`${curPath}: expected one of ${schema.enum.map((item) => JSON.stringify(item)).join(", ")}`);
-  }
-
-  if (typeof value === "string") {
-    if (typeof schema.minLength === "number" && value.length < schema.minLength) {
-      errors.push(`${curPath}: expected minLength ${schema.minLength}`);
-    }
-    if (typeof schema.pattern === "string") {
-      const re = new RegExp(schema.pattern);
-      if (!re.test(value)) errors.push(`${curPath}: does not match pattern ${schema.pattern}`);
-    }
-  }
-
-  if (Array.isArray(value)) {
-    if (typeof schema.minItems === "number" && value.length < schema.minItems) {
-      errors.push(`${curPath}: expected minItems ${schema.minItems}`);
-    }
-    if (schema.items) {
-      value.forEach((item, index) => validateNode(item, schema.items, rootSchema, joinPath(curPath, `[${index}]`), errors));
-    }
-  }
-
-  if (isPlainObject(value)) {
-    const entries = Object.keys(value);
-    if (typeof schema.minProperties === "number" && entries.length < schema.minProperties) {
-      errors.push(`${curPath}: expected minProperties ${schema.minProperties}`);
-    }
-    if (typeof schema.maxProperties === "number" && entries.length > schema.maxProperties) {
-      errors.push(`${curPath}: expected maxProperties ${schema.maxProperties}`);
-    }
-    const properties = isPlainObject(schema.properties) ? schema.properties : {};
-    const required = Array.isArray(schema.required) ? schema.required : [];
-    for (const key of required) {
-      if (!Object.prototype.hasOwnProperty.call(value, key)) errors.push(`${curPath}: missing required property ${key}`);
-    }
-    for (const [key, childSchema] of Object.entries(properties)) {
-      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
-      validateNode(value[key], childSchema, rootSchema, joinPath(curPath, `.${key}`), errors);
-    }
-    if (schema.additionalProperties === false) {
-      for (const key of entries) {
-        if (!Object.prototype.hasOwnProperty.call(properties, key)) {
-          errors.push(`${curPath}: unexpected property ${key}`);
-        }
-      }
-    }
-  }
-}
-
-/**
- * @param {any} value
- * @param {any} schema
- * @param {{ source: string }} options
- */
-export function validateJsonSchemaLite(value, schema, options) {
-  const errors = [];
-  validateNode(value, schema, schema, "$", errors);
-  if (errors.length > 0) {
-    throw new UserError("Spec doc schema validation failed.", {
-      details: [options?.source || "", ...errors].filter(Boolean).join("\n"),
-    });
-  }
-}

package/src/managed-blocks.js

@@ -1,131 +0,0 @@
-import { normalizeNewlines, sha256Text } from "./hash.js";
-import { UserError } from "./errors.js";
-
-/**
- * @param {string} s
- * @returns {string}
- */
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/**
- * @param {string} text
- * @param {string} blockId
- * @returns {{ beginLineIndex: number, endLineIndex: number, innerText: string, beginLine: string, endLine: string } | null}
- */
-export function findManagedBlock(text, blockId) {
-  const t = normalizeNewlines(text);
-  const lines = t.split("\n");
-  const beginRe = new RegExp(`AIWS_MANAGED_BEGIN:${escapeRegExp(blockId)}(?:\\s|$|-->)`);
-  const endRe = new RegExp(`AIWS_MANAGED_END:${escapeRegExp(blockId)}(?:\\s|$|-->)`);
-
-  let beginLineIndex = -1;
-  let endLineIndex = -1;
-
-  for (let i = 0; i < lines.length; i++) {
-    if (beginLineIndex === -1 && beginRe.test(lines[i] ?? "")) {
-      beginLineIndex = i;
-      continue;
-    }
-    if (beginLineIndex !== -1 && endRe.test(lines[i] ?? "")) {
-      endLineIndex = i;
-      break;
-    }
-  }
-
-  if (beginLineIndex === -1 || endLineIndex === -1 || endLineIndex <= beginLineIndex) return null;
-
-  const innerLines = lines.slice(beginLineIndex + 1, endLineIndex);
-  let innerText = innerLines.join("\n");
-  if (innerLines.length > 0) innerText += "\n";
-
-  return {
-    beginLineIndex,
-    endLineIndex,
-    innerText,
-    beginLine: lines[beginLineIndex] ?? "",
-    endLine: lines[endLineIndex] ?? "",
-  };
-}
-
-/**
- * Extract the canonical block chunk (begin+inner+end) from a template file.
- *
- * @param {string} templateText
- * @param {string} blockId
- * @returns {{ blockChunk: string, innerText: string }}
- */
-export function extractTemplateBlock(templateText, blockId) {
-  const t = normalizeNewlines(templateText);
-  const block = findManagedBlock(t, blockId);
-  if (!block) {
-    throw new UserError(`Template is missing managed block: ${blockId}`, { exitCode: 1 });
-  }
-  const blockChunk = `${block.beginLine}\n${block.innerText}${block.endLine}\n`;
-  return { blockChunk, innerText: block.innerText };
-}
-
-/**
- * @param {string} targetText
- * @param {string} blockId
- * @param {string} newInnerText normalized; may end with "\n"
- * @param {{ insertIfMissing: boolean, templateBlockChunk?: string } } options
- * @returns {{ nextText: string, changed: boolean, inserted: boolean }}
- */
-export function upsertManagedBlock(targetText, blockId, newInnerText, options) {
-  const original = normalizeNewlines(targetText);
-  const block = findManagedBlock(original, blockId);
-  if (!block) {
-    if (!options.insertIfMissing) {
-      throw new UserError(`Missing managed block: ${blockId}`);
-    }
-    if (!options.templateBlockChunk) {
-      throw new UserError(`Cannot insert managed block without template chunk: ${blockId}`, { exitCode: 1 });
-    }
-    const nextText = insertBlockAtTop(original, options.templateBlockChunk);
-    return { nextText, changed: true, inserted: true };
-  }
-
-  const lines = original.split("\n");
-  const begin = lines.slice(0, block.beginLineIndex + 1);
-  const end = lines.slice(block.endLineIndex);
-
-  const innerLines = newInnerText.endsWith("\n") ? newInnerText.slice(0, -1).split("\n") : newInnerText.split("\n");
-  const rebuilt = [...begin, ...innerLines, ...end].join("\n");
-
-  return { nextText: rebuilt, changed: rebuilt !== original, inserted: false };
-}
-
-/**
- * Insert block chunk near the top with minimal disruption:
- * - If the file starts with a Markdown heading (`# ...`), insert after the first line.
- * - Otherwise, insert at the very top.
- *
- * @param {string} text normalized
- * @param {string} blockChunk normalized; should end with "\n"
- */
-function insertBlockAtTop(text, blockChunk) {
-  const t = normalizeNewlines(text);
-  const chunk = normalizeNewlines(blockChunk).endsWith("\n") ? normalizeNewlines(blockChunk) : `${normalizeNewlines(blockChunk)}\n`;
-
-  const lines = t.split("\n");
-  if (lines.length > 0 && (lines[0] ?? "").startsWith("# ")) {
-    const after = lines.slice(1).join("\n");
-    const head = `${lines[0]}\n`;
-    return `${head}\n${chunk}\n${after}`.replace(/\n{3,}/g, "\n\n");
-  }
-  return `${chunk}\n${t}`.replace(/\n{3,}/g, "\n\n");
-}
-
-/**
- * @param {string} text
- * @param {string} blockId
- */
-export function hashManagedBlockInner(text, blockId) {
-  const block = findManagedBlock(text, blockId);
-  if (!block) {
-    throw new UserError(`Missing managed block: ${blockId}`);
-  }
-  return sha256Text(block.innerText);
-}