@cassiomc1/forgeloop 1.12.0 → 1.14.0

package/src/core/semantic-planning/projection.js

@@ -0,0 +1,94 @@
+import { FAILURE_CLASSES, DIAGNOSIS_STRATEGIES, REVIEW_FOCUSES } from "./constants.js";
+
+function strings(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim()) : [];
+}
+
+function text(input) {
+  return [input?.message, input?.error, input?.failure, input?.objective, ...(input?.paths ?? []), ...(input?.risks ?? [])]
+    .filter((value) => typeof value === "string").join(" ").toLowerCase();
+}
+
+function unique(values) { return [...new Set(values)]; }
+
+function validateRecommendation(recommendation, allowed, label) {
+  if (recommendation === undefined || recommendation === null) return null;
+  const values = typeof recommendation === "string" ? [recommendation]
+    : recommendation && typeof recommendation === "object" && !Array.isArray(recommendation)
+      ? Object.entries(recommendation).filter(([, value]) => value === true).map(([key]) => key)
+      : strings(recommendation);
+  const unknown = values.filter((value) => !allowed.includes(value));
+  if (unknown.length > 0) {
+    const error = new Error(`${label} contains unknown semantic values: ${unknown.join(", ")}`);
+    error.code = "E_DECISION_RESULT_INVALID";
+    throw error;
+  }
+  return unique(values);
+}
+
+export function projectFailureTriage({ input = {}, semanticRecommendation = null } = {}) {
+  const candidate = semanticRecommendation?.failureClass ?? semanticRecommendation;
+  const value = validateRecommendation(candidate, FAILURE_CLASSES, "failure recommendation");
+  const inferred = /timeout|timed out/.test(text(input)) ? "timeout"
+    : /network|dns|connection|environment/.test(text(input)) ? "network/environment"
+      : /ownership|protocol|ledger|phase/.test(text(input)) ? "ownership/protocol mismatch"
+        : "unknown";
+  return {
+    decisionKind: "FAILURE_TRIAGE",
+    questionSetId: "failure-v1",
+    candidates: [...FAILURE_CLASSES],
+    ranked: unique([...(value ?? []), inferred]),
+    semanticRequired: true,
+    unknownEscalates: !value,
+    authority: "SEMANTIC_DECISION",
+    evidenceAuthority: "NONE",
+  };
+}
+
+export function projectDiagnosisPriority({ input = {}, semanticRecommendation = null } = {}) {
+  const candidate = semanticRecommendation?.priority ?? semanticRecommendation;
+  const value = validateRecommendation(candidate, DIAGNOSIS_STRATEGIES, "diagnosis recommendation");
+  const inferred = /race|concurr|lock/.test(text(input)) ? "inspect concurrency path"
+    : /state|ledger|phase|fingerprint/.test(text(input)) ? "inspect state transition"
+      : /depend|package|module/.test(text(input)) ? "inspect dependency behavior"
+        : "run narrower experiment";
+  return {
+    decisionKind: "DIAGNOSIS_PRIORITY",
+    questionSetId: "diagnosis-v1",
+    candidates: [...DIAGNOSIS_STRATEGIES],
+    ranked: unique([...(value ?? []), inferred]),
+    previouslyFailed: strings(input.previouslyFailed),
+    semanticRequired: true,
+    unknownEscalates: !value,
+    authority: "SEMANTIC_DECISION",
+    evidenceAuthority: "NONE",
+  };
+}
+
+export function projectReviewPlan({ input = {}, semanticRecommendation = null } = {}) {
+  const candidate = semanticRecommendation?.reviewFocus ?? semanticRecommendation;
+  const value = validateRecommendation(candidate, REVIEW_FOCUSES, "review recommendation");
+  const body = text(input);
+  const mandatory = ["needs_full_diff_context"];
+  if (/security|secret|credential|auth|permission/.test(body)) mandatory.push("needs_security_review");
+  if (/api|public|compatib/.test(body)) mandatory.push("needs_api_compatibility_review");
+  if (/race|concurr|lock/.test(body)) mandatory.push("needs_concurrency_review");
+  if (/package|release|dependency/.test(body)) mandatory.push("needs_package_review", "needs_dependency_review");
+  if (/doc|readme|guide/.test(body)) mandatory.push("needs_docs_review");
+  if (/migration|schema|database/.test(body)) mandatory.push("needs_migration_review");
+  if (/performance|timeout|latency/.test(body)) mandatory.push("needs_performance_review");
+  if (input.fullDiff === true || body.includes("full diff")) mandatory.push("needs_full_diff_context");
+  const ranked = unique([...mandatory, ...(value ?? [])]);
+  if (ranked.length === 0) ranked.push("needs_full_diff_context");
+  if (input.primaryModel === true || input.ambiguity === true) ranked.push("needs_primary_model");
+  return {
+    decisionKind: "REVIEW_PLAN",
+    questionSetId: "review-v1",
+    mandatory: unique(mandatory),
+    ranked: unique(ranked),
+    semanticRequired: true,
+    unknownEscalates: !value,
+    authority: "SEMANTIC_DECISION",
+    evidenceAuthority: "NONE",
+  };
+}

package/src/core/semantic-planning/service.js

@@ -0,0 +1,15 @@
+import { DECISION_ERROR_CODES, decisionError } from "../decision/errors.js";
+import { projectDiagnosisPriority, projectFailureTriage, projectReviewPlan } from "./projection.js";
+
+const PROJECTORS = Object.freeze({
+  failure: projectFailureTriage,
+  diagnosis: projectDiagnosisPriority,
+  review: projectReviewPlan,
+});
+
+export function runSemanticPlan({ kind, input = {}, semanticRecommendation = null } = {}) {
+  const projector = PROJECTORS[kind];
+  if (!projector) throw decisionError(DECISION_ERROR_CODES.QUESTION_SET_UNKNOWN, `Unknown semantic plan kind: ${kind}`);
+  return projector({ input, semanticRecommendation });
+}
+

package/src/core/sources.js

@@ -1,5 +1,19 @@
+import { CONTRACT_PRESET_IDS } from "./contract-presets.js";
 import { PROTOCOL_VERSION } from "./protocol.js";
 
+const CONTRACT_PRESET_PREFIX = "contract-preset:";
+const BUILTIN_CONTRACT_PRESET_REFS = new Set(
+  CONTRACT_PRESET_IDS.map((presetId) => `${CONTRACT_PRESET_PREFIX}${presetId}`),
+);
+
+export function isBuiltinContractPresetRef(ref) {
+  return typeof ref === "string" && BUILTIN_CONTRACT_PRESET_REFS.has(ref);
+}
+
+export function externalContractSourceRefs(refs = []) {
+  return refs.filter((ref) => !isBuiltinContractPresetRef(ref));
+}
+
 export const SOURCE_REGISTRY_SCHEMA_VERSION = 1;
 export const SOURCE_KINDS = Object.freeze([
   "user-request",
@@ -84,3 +98,26 @@ export function assertSourceProvenance(registry, refs = [], { expectedKind } = {
   }
   return true;
 }
+
+export function assertContractPresetRefs(refs = []) {
+  for (const ref of refs) {
+    if (typeof ref === "string" && ref.startsWith(CONTRACT_PRESET_PREFIX) && !isBuiltinContractPresetRef(ref)) {
+      const error = new Error(`Unknown built-in contract preset source: ${ref}`);
+      error.code = "E_PROFILE_SOURCE_UNKNOWN";
+      throw error;
+    }
+  }
+  return true;
+}
+
+export function assertContractSourceProvenance(registry, refs = []) {
+  assertContractPresetRefs(refs);
+  const externalRefs = externalContractSourceRefs(refs);
+  if (externalRefs.length === 0) return true;
+  if (!registry) {
+    const error = new Error("External contract source references require a source registry");
+    error.code = "E_PROFILE_SOURCE_MISSING";
+    throw error;
+  }
+  return assertSourceProvenance(registry, externalRefs);
+}

package/src/core/sql-project.js

@@ -0,0 +1,141 @@
+import { parseXmlStructure } from "./xml-structure.js";
+
+const SQL_STATEMENT_PATTERNS = Object.freeze([
+  /(?:^|[;\n])\s*select\b[\s\S]{0,240}\bfrom\s+[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)*(?:\s*(?:;|$)|\s+(?:where|group|order|having|limit|offset|union|join|left|right|inner|outer|on)\b)/imu,
+  /(?:^|[;\n])\s*select\s+(?:distinct\s+)?[-+]?\d+(?:\s*,\s*[-+]?\d+)*\s*;?\s*(?:$|[\n])/imu,
+  /(?:^|[;\n])\s*insert\s+into\b/imu,
+  /(?:^|[;\n])\s*update\b[\s\S]{0,160}\bset\b/imu,
+  /(?:^|[;\n])\s*delete\s+from\b/imu,
+  /(?:^|[;\n])\s*merge\s+into\b/imu,
+  /(?:^|[;\n])\s*with\b[\s\S]{0,1024}\bas\s*\([\s\S]*\)\s*(?:select|insert|update|delete|merge)\b/imu,
+  /(?:^|[;\n])\s*create\s+(?:table|view|index|schema|database|function|procedure|trigger|type|sequence)\s+(?:if\s+not\s+exists\s+)?[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)*(?:\s*(?:\(|;|$)|\s+(?:as|like)\b)/imu,
+  /(?:^|[;\n])\s*alter\s+(?:table|view|index|schema|database|function|procedure|trigger|type|sequence)\s+(?:if\s+exists\s+)?[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)*(?:\s*(?:;|$)|\s+(?:add|drop|alter|rename|set|owner|enable|disable)\b)/imu,
+  /(?:^|[;\n])\s*drop\s+(?:table|view|index|schema|database|function|procedure|trigger|type|sequence)\s+(?:if\s+exists\s+)?[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)*(?:\s*(?:;|$)|\s+(?:cascade|restrict)\b)/imu,
+  /(?:^|[;\n])\s*(?:grant|revoke)\b[\s\S]{0,240}\bon\b/imu,
+  /(?:^|[;\n])\s*begin(?:\s+(?:transaction|work))?\s*;?\s*(?:$|[\n])/imu,
+  /(?:^|[;\n])\s*(?:commit|rollback)(?:\s+(?:transaction|work))?\s*;?\s*(?:$|[\n])/imu,
+  /(?:^|[;\n])\s*savepoint\s+[A-Za-z_][A-Za-z0-9_$]*\s*;?/imu,
+  /(?:^|[;\n])\s*release\s+savepoint\s+[A-Za-z_][A-Za-z0-9_$]*\s*;?/imu,
+]);
+
+function maskSqlComment(text, start, block) {
+  const lineEnd = text.slice(start).search(/[\n\r]/u);
+  const end = block ? text.indexOf("*/", start + 2) : lineEnd < 0 ? -1 : start + lineEnd;
+  if (block && end < 0) return null;
+  const finish = block ? end + 2 : (end < 0 ? text.length : end);
+  const value = text.slice(start, finish);
+  return { text: value.replace(/[^\n\r]/gu, " "), next: finish };
+}
+
+function maskSqlQuoted(text, start, quote) {
+  let result = " ";
+  for (let index = start + 1; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (character === quote && next === quote) {
+      result += "  ";
+      index += 1;
+    } else if (character === quote) {
+      return { text: result + " ", next: index + 1 };
+    } else {
+      result += character === "\n" || character === "\r" ? character : " ";
+    }
+  }
+  return null;
+}
+
+function maskSqlQuotedIdentifier(text, start, quote) {
+  for (let index = start + 1; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (character === quote && next === quote) {
+      index += 1;
+    } else if (character === quote) {
+      return { text: "__identifier__", next: index + 1 };
+    }
+  }
+  return null;
+}
+
+function maskSqlBracketIdentifier(text, start) {
+  for (let index = start + 1; index < text.length; index += 1) {
+    if (text[index] === "]") {
+      if (text[index + 1] === "]") {
+        index += 1;
+      } else {
+        return { text: "__identifier__", next: index + 1 };
+      }
+    }
+  }
+  return null;
+}
+
+function maskSqlDollarQuote(text, start) {
+  const marker = text.slice(start).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/u)?.[0];
+  if (!marker) return null;
+  const end = text.indexOf(marker, start + marker.length);
+  if (end < 0) return { invalid: true };
+  const finish = end + marker.length;
+  return { text: text.slice(start, finish).replace(/[^\n\r]/gu, " "), next: finish };
+}
+
+function maskSqlToken(text, index) {
+  const character = text[index];
+  const next = text[index + 1];
+  if (character === "-" && next === "-") {
+    return maskSqlComment(text, index, false);
+  }
+  if (character === "/" && next === "*") return maskSqlComment(text, index, true);
+  if (character === "'") return maskSqlQuoted(text, index, character);
+  if (character === '"' || character === "`") return maskSqlQuotedIdentifier(text, index, character);
+  if (character === "[") return maskSqlBracketIdentifier(text, index);
+  if (character === "$") {
+    const dollarQuote = maskSqlDollarQuote(text, index);
+    if (dollarQuote?.invalid) return null;
+    return dollarQuote ?? { text: character, next: index + 1 };
+  }
+  return { text: character, next: index + 1 };
+}
+
+function maskSql(text) {
+  let result = "";
+  for (let index = 0; index < text.length;) {
+    const segment = maskSqlToken(text, index);
+    if (!segment) return null;
+    result += segment.text;
+    index = segment.next;
+  }
+  return result;
+}
+
+export function looksLikeSql(text) {
+  if (typeof text !== "string" || text.length > 512 * 1024 || /\r(?!\n)/u.test(text)) return false;
+  const masked = maskSql(text);
+  return masked !== null && SQL_STATEMENT_PATTERNS.some((pattern) => pattern.test(masked));
+}
+
+export function sqlSignal(text) {
+  if (!looksLikeSql(text)) return null;
+  const masked = maskSql(text);
+  return masked === null ? null : SQL_STATEMENT_PATTERNS.find((pattern) => pattern.test(masked))?.source ?? "statement";
+}
+
+function childValues(node, name) {
+  return node.children
+    .filter((child) => child.name.toLowerCase() === name)
+    .map((child) => child.text.trim())
+    .filter(Boolean);
+}
+
+export function parseSqlProject(text) {
+  const document = parseXmlStructure(text);
+  if (!document || document.root.name.toLowerCase() !== "project") return { valid: false, database: false };
+  const sdk = document.root.attributes.Sdk ?? document.root.attributes.sdk ?? "";
+  const databaseMarkers = [
+    sdk.toLowerCase().startsWith("microsoft.build.sql/"),
+    childValues(document.root, "dsp").length > 0,
+    document.nodes.some((node) => ["databaseproject", "sqlscript"].includes(node.name.toLowerCase())),
+  ];
+  const database = databaseMarkers.some(Boolean);
+  return { valid: database, database };
+}

package/src/core/swift-project.js

@@ -0,0 +1,200 @@
+import { createLanguageProject, C_SOURCE_EXTENSIONS, CPP_SOURCE_EXTENSIONS, SWIFT_SOURCE_EXTENSIONS, pathBelongsToRoot, portablePath } from "./multi-language-project.js";
+import { extractBuildCalls, maskBuildScript, quotedBuildArguments } from "./build-script.js";
+
+function invalidSwift() {
+  return { valid: false, swift: false, c: false, cpp: false };
+}
+
+function stripSwiftComments(text) {
+  let result = "";
+  let state = "code";
+  let escaped = false;
+  let blockDepth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (state === "string") {
+      result += character;
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') state = "code";
+    } else if (state === "line-comment") {
+      if (character === "\n") {
+        result += character;
+        state = "code";
+      } else result += " ";
+    } else if (state === "block-comment") {
+      if (character === "/" && next === "*") {
+        blockDepth += 1;
+        result += "  ";
+        index += 1;
+      } else if (character === "*" && next === "/") {
+        blockDepth -= 1;
+        result += "  ";
+        index += 1;
+        if (blockDepth === 0) state = "code";
+      } else result += character === "\n" ? "\n" : " ";
+    } else if (character === '"') {
+      result += character;
+      state = "string";
+    } else if (character === "/" && next === "/") {
+      result += "  ";
+      index += 1;
+      state = "line-comment";
+    } else if (character === "/" && next === "*") {
+      result += "  ";
+      index += 1;
+      blockDepth = 1;
+      state = "block-comment";
+    } else result += character;
+  }
+  return state === "block-comment" ? null : result;
+}
+
+function maskSwiftStrings(text) {
+  let result = "";
+  let state = "code";
+  let escaped = false;
+  let delimiter = null;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const rawMatch = character === "#" ? text.slice(index).match(/^(#+)("{1,3})/u) : null;
+    if (state === "string") {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (text.startsWith(delimiter, index)) {
+        result += " ".repeat(delimiter.length);
+        index += delimiter.length - 1;
+        state = "code";
+        delimiter = null;
+        continue;
+      }
+      result += character === "\n" ? "\n" : " ";
+    } else if (character === '"') {
+      delimiter = text.startsWith('"""', index) ? '"""' : '"';
+      state = "string";
+      result += " ".repeat(delimiter.length);
+      index += delimiter.length - 1;
+    } else if (rawMatch) {
+      delimiter = `${rawMatch[2]}${rawMatch[1]}`;
+      state = "string";
+      result += " ".repeat(rawMatch[0].length);
+      index += rawMatch[0].length - 1;
+    } else {
+      result += character;
+    }
+  }
+  return state === "string" ? null : result;
+}
+
+function maskSwiftLexicalNoise(text) {
+  const withoutComments = stripSwiftComments(text);
+  return withoutComments === null ? null : maskSwiftStrings(withoutComments);
+}
+
+function hasBalancedSwiftDelimiters(source) {
+  const expectedClosers = new Map([
+    ["(", ")"],
+    ["{", "}"],
+    ["[", "]"],
+  ]);
+  const stack = [];
+  for (const character of source) {
+    if (expectedClosers.has(character)) {
+      stack.push(expectedClosers.get(character));
+    } else if (")]}".includes(character) && stack.pop() !== character) {
+      return false;
+    }
+  }
+  return stack.length === 0;
+}
+
+export function parseSwiftPackage(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidSwift();
+  const toolsVersion = /^\s*\/\/\s*swift-tools-version:\s*\d+(?:\.\d+){1,2}\s*$/mu.test(text);
+  const source = maskSwiftLexicalNoise(text);
+  const packageDescription = source !== null && /\bimport\s+PackageDescription\b/u.test(source);
+  const balanced = source !== null && hasBalancedSwiftDelimiters(source);
+  const packageDeclaration = source !== null && /\bPackage\s*\(/u.test(source);
+  return {
+    valid: toolsVersion && packageDescription && packageDeclaration && balanced,
+    swift: toolsVersion && packageDescription && packageDeclaration && balanced,
+    c: false,
+    cpp: false,
+  };
+}
+
+export function parseXcodeProject(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidSwift();
+  const source = stripSwiftComments(text);
+  const swift = source !== null && /\bSWIFT_VERSION\s*=/u.test(source) && /\.swift\b/u.test(source);
+  return { valid: swift, swift, c: false, cpp: false };
+}
+
+export function parseSwiftCMake(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidSwift();
+  const source = maskBuildScript(text);
+  const swift = source !== null && /\b(?:LANGUAGES[^\n)]*\bSwift\b|enable_language\s*\(\s*Swift\b)/iu.test(source);
+  return { valid: swift, swift, c: false, cpp: false };
+}
+
+export function parseSwiftMeson(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidSwift();
+  const calls = extractBuildCalls(text, ["project", "add_languages"]);
+  const swift = Boolean(calls?.some((call) => {
+    const values = quotedBuildArguments(call.body) ?? [];
+    return (call.name === "project" ? values.slice(1) : values)
+      .some((value) => value.toLowerCase() === "swift");
+  }));
+  return { valid: swift, swift, c: false, cpp: false };
+}
+
+function sourceEvidence(sourceFiles, targetRoot, projectRoot, projectRoots) {
+  const owns = (file) => pathBelongsToRoot(portablePath(targetRoot, file.path), projectRoot, projectRoots);
+  return {
+    swift: sourceFiles.some((file) => SWIFT_SOURCE_EXTENSIONS.has(file.extension) && owns(file)),
+    c: sourceFiles.some((file) => C_SOURCE_EXTENSIONS.has(file.extension) && owns(file)),
+    cpp: sourceFiles.some((file) => CPP_SOURCE_EXTENSIONS.has(file.extension) && owns(file)),
+  };
+}
+
+export function swiftSourceLooksExecutable(text) {
+  const source = maskSwiftLexicalNoise(text);
+  return source !== null && /\b(?:import|class|struct|enum|protocol|func|let|var)\b/u.test(source);
+}
+
+export function inspectSwiftProject({ projectRoot, manifestRelative, manifestText, manifestName, targetRoot, sourceFiles, projectRoots, directClaim = false }) {
+  const normalizedManifestName = manifestName.toLowerCase();
+  const parsed = normalizedManifestName === "package.swift"
+    ? parseSwiftPackage(manifestText)
+    : normalizedManifestName === "project.pbxproj"
+      ? parseXcodeProject(manifestText)
+      : normalizedManifestName === "meson.build"
+        ? parseSwiftMeson(manifestText)
+      : parseSwiftCMake(manifestText);
+  const source = sourceEvidence(sourceFiles, targetRoot, projectRoot, projectRoots);
+  const swift = parsed.swift
+    && (normalizedManifestName !== "package.swift" || source.swift || directClaim);
+  const frameworks = [];
+  if (swift) frameworks.push("swift");
+  if (normalizedManifestName === "package.swift" && parsed.valid && source.c) frameworks.push("c");
+  if (normalizedManifestName === "package.swift" && parsed.valid && source.cpp) frameworks.push("cpp");
+  const primary = frameworks.length > 0;
+  const primarySignals = [];
+  const manifestSignal = normalizedManifestName === "package.swift"
+    ? "package"
+    : normalizedManifestName === "project.pbxproj" ? "xcode" : "build";
+  if (swift) primarySignals.push(`${manifestRelative}:${manifestSignal}`);
+  if (normalizedManifestName === "package.swift" && parsed.valid && source.c) primarySignals.push(`${projectRoot}/source:c`);
+  if (normalizedManifestName === "package.swift" && parsed.valid && source.cpp) primarySignals.push(`${projectRoot}/source:cpp`);
+  return createLanguageProject({
+    kind: "swift",
+    root: projectRoot,
+    manifest: manifestRelative,
+    frameworks,
+    primary,
+    primarySignals,
+    supportingSignals: [],
+    internal: { ...parsed, valid: parsed.valid, source },
+  });
+}