📦 deps(thirdparty): update snapshots

2026-07-18 00:02:59 +00:00
parent 82f7c6e56a
commit 47ce7f78dc
1446 changed files with 141041 additions and 6442 deletions
@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { canonicalJson, sha256 } = require("../lib/aas-v1/canonical-json");
+const { compareStrings, sortedUnique, tokenize } = require("../lib/aas-v1/normalize");
+
+const ROOT = path.resolve(__dirname, "../..");
+const CATALOG_PATH = path.join(ROOT, "data/catalog.json");
+const COMPATIBILITY_PATH = path.join(ROOT, "data/plugin-compatibility.json");
+const ONTOLOGY_PATH = path.join(ROOT, "tools/lib/aas-v1/ontology.v1.json");
+const OUTPUT_PATH = path.join(ROOT, "tools/lib/aas-v1/review-queue.v1.json");
+const MAX_CANDIDATES_PER_CAPABILITY = 25;
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function sourceKnown(skill) {
+  const value = skill.source_type || skill.source_repo || skill.source;
+  return typeof value === "string" && value.length > 0 && value !== "unknown";
+}
+
+function candidateTokens(skill) {
+  return sortedUnique(tokenize([
+    skill.id,
+    skill.canonical_id,
+    skill.name,
+    skill.category,
+    ...(skill.tags || []),
+  ]));
+}
+
+function buildReviewQueue() {
+  const catalog = readJson(CATALOG_PATH);
+  const compatibility = readJson(COMPATIBILITY_PATH);
+  const ontology = readJson(ONTOLOGY_PATH);
+  if (!ontology.capabilities || typeof ontology.capabilities !== "object") {
+    throw new Error("ontology.v1.json must define a capabilities object");
+  }
+  const compatibilityById = new Map((compatibility.skills || []).map((entry) => [entry.id, entry]));
+  const skills = (catalog.skills || []).map((skill) => ({
+    skill,
+    tokens: candidateTokens(skill),
+    compatibility: compatibilityById.get(skill.id) || {},
+  }));
+  const queues = [];
+  for (const intent of Object.keys(ontology.capabilities).sort(compareStrings)) {
+    const intentTokens = new Set(tokenize([intent, ...(ontology.intentAliases[intent] || [])]));
+    for (const capability of [...ontology.capabilities[intent]].sort(compareStrings)) {
+      const queryTokens = sortedUnique(tokenize(capability));
+      const candidates = skills.map(({ skill, tokens, compatibility: plugin }) => {
+        const tokenSet = new Set(tokens);
+        const matchedCapabilityTokens = queryTokens.filter((token) => tokenSet.has(token));
+        const intentTokenMatches = [...intentTokens].filter((token) => tokenSet.has(token)).length;
+        const exactId = skill.id === capability || skill.canonical_id === capability;
+        const exactTag = (skill.tags || []).includes(capability);
+        const knownRisk = ["none", "safe"].includes(skill.risk);
+        const knownSource = sourceKnown(skill);
+        const supportedTargets = ["codex", "claude"].filter((host) => plugin.targets?.[host] === "supported");
+        const setup = plugin.setup?.type || "unknown";
+        const eligibleEvidenceShape = knownRisk && knownSource && supportedTargets.length > 0
+          && ["none", "automatic"].includes(setup);
+        const score = (exactId ? 100000 : 0)
+          + (exactTag ? 50000 : 0)
+          + matchedCapabilityTokens.length * 10000
+          + intentTokenMatches * 100
+          + (eligibleEvidenceShape ? 10 : 0);
+        return {
+          id: skill.canonical_id || skill.id,
+          score,
+          factors: {
+            eligibleEvidenceShape,
+            exactId,
+            exactTag,
+            intentTokenMatches,
+            matchedCapabilityTokens,
+          },
+        };
+      }).filter((entry) => entry.score > 0)
+        .sort((left, right) => right.score - left.score || compareStrings(left.id, right.id))
+        .slice(0, MAX_CANDIDATES_PER_CAPABILITY)
+        .map((entry, index) => ({ ...entry, rank: index + 1 }));
+      queues.push({ intent, capability, queryTokens, candidates });
+    }
+  }
+  return {
+    schemaVersion: 1,
+    queueVersion: 1,
+    selectionPolicy: {
+      kind: "catalog-structured-lexical-top-k",
+      maximumCandidatesPerCapability: MAX_CANDIDATES_PER_CAPABILITY,
+      benchmarkIndependent: true,
+      candidateFields: ["id", "canonical_id", "name", "category", "tags"],
+      scoreFactors: ["exactId", "exactTag", "matchedCapabilityTokens", "intentTokenMatches", "eligibleEvidenceShape"],
+      stableTieBreak: "canonical-skill-id",
+    },
+    inputs: {
+      catalog: sha256(fs.readFileSync(CATALOG_PATH)),
+      compatibility: sha256(fs.readFileSync(COMPATIBILITY_PATH)),
+      ontology: sha256(fs.readFileSync(ONTOLOGY_PATH)),
+    },
+    queues,
+  };
+}
+
+function main() {
+  const built = buildReviewQueue();
+  const serialized = `${canonicalJson(built)}\n`;
+  if (process.argv.includes("--write")) {
+    fs.writeFileSync(OUTPUT_PATH, serialized, { mode: 0o644 });
+    process.stdout.write(`Wrote ${built.queues.length} public capability review queues.\n`);
+    return;
+  }
+  if (fs.readFileSync(OUTPUT_PATH, "utf8") !== serialized) {
+    throw new Error("review-queue.v1.json is stale; run with --write");
+  }
+  process.stdout.write(`Validated ${built.queues.length} public capability review queues.\n`);
+}
+
+if (require.main === module) main();
+
+module.exports = { buildReviewQueue, candidateTokens, sourceKnown };