csh/playbook
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

📦 deps(thirdparty): update snapshots

Browse Source
This commit is contained in:
ci[bot]
2026-07-20 00:03:02 +00:00
parent 47ce7f78dc
commit 2c00adccd5
1216 changed files with 10376 additions and 90058 deletions
Download Patch File Download Diff File Expand all files Collapse all files
antigravity-awesome-skills/tools/lib/aas-v1/normalize.js
-143
View File
@@ -1,16 +1,6 @@
"use strict";
const ontology = require("./ontology.v1.json");
const { validateInstance } = require("./schema-validator");
const ALLOWED_PROFILE_FIELDS = new Set([
"projectType",
"languages",
"frameworks",
"context",
"constraints",
"request",
]);
function compareStrings(left, right) {
return left < right ? -1 : (left > right ? 1 : 0);
@@ -44,142 +34,9 @@ function sortedUnique(values) {
return [...new Set(values.filter(Boolean))].sort(compareStrings);
}
function normalizeStringArray(value, field, maximum = 32) {
if (value === undefined) return [];
if (!Array.isArray(value) || value.length > maximum || value.some((item) => typeof item !== "string")) {
const error = new Error(`${field} must be an array of at most ${maximum} strings`);
error.code = "AAS_INPUT_ARRAY_INVALID";
throw error;
}
return sortedUnique(value.map((item) => normalizeToken(item)));
}
function normalizeProfile(profile = {}) {
if (!profile || typeof profile !== "object" || Array.isArray(profile)) {
const error = new Error("profile must be an object");
error.code = "AAS_INPUT_PROFILE_INVALID";
throw error;
}
const forbidden = Object.keys(profile).filter((field) => !ALLOWED_PROFILE_FIELDS.has(field));
if (forbidden.length) {
const error = new Error("profile contains forbidden fields");
error.code = "AAS_INPUT_PROFILE_FIELD_FORBIDDEN";
error.details = { fields: forbidden.sort() };
throw error;
}
const result = {};
for (const field of ["projectType", "context", "request"]) {
if (profile[field] !== undefined) {
if (typeof profile[field] !== "string" || profile[field].length > 2048) {
const error = new Error(`${field} must be a bounded string`);
error.code = "AAS_INPUT_STRING_INVALID";
throw error;
}
result[field] = profile[field].normalize("NFKC").trim();
}
}
result.languages = normalizeStringArray(profile.languages, "profile.languages");
result.frameworks = normalizeStringArray(profile.frameworks, "profile.frameworks");
result.constraints = normalizeStringArray(profile.constraints, "profile.constraints");
return result;
}
function normalizeTargets(targets) {
if (!Array.isArray(targets) || targets.length === 0 || targets.length > 8) {
const error = new Error("targets must contain between one and eight entries");
error.code = "AAS_INPUT_TARGETS_INVALID";
throw error;
}
return targets.map((target) => {
if (!target || !["codex", "claude"].includes(target.host) || !["project", "user"].includes(target.scope)) {
const error = new Error("target host or scope is unsupported in v1");
error.code = "AAS_INPUT_TARGET_UNSUPPORTED";
throw error;
}
return { host: target.host, scope: target.scope };
}).sort((left, right) => compareStrings(`${left.host}:${left.scope}`, `${right.host}:${right.scope}`));
}
function normalizePolicy(policy = {}) {
const allowedRisk = normalizeStringArray(policy.allowedRisk ?? ["none", "safe"], "policy.allowedRisk", 5);
if (allowedRisk.some((risk) => !["none", "safe", "unknown", "critical", "offensive"].includes(risk))) {
const error = new Error("policy.allowedRisk contains an unsupported value");
error.code = "AAS_INPUT_POLICY_INVALID";
throw error;
}
return {
allowedRisk,
requireKnownSource: policy.requireKnownSource === true,
allowManualSetup: policy.allowManualSetup === true,
};
}
function normalizeRecommendationInput(input) {
if (!input || typeof input !== "object" || Array.isArray(input)) {
const error = new Error("recommendation input must be an object");
error.code = "AAS_INPUT_INVALID";
throw error;
}
if (input.profile && typeof input.profile === "object" && !Array.isArray(input.profile)) {
const forbiddenProfileFields = Object.keys(input.profile).filter((field) => !ALLOWED_PROFILE_FIELDS.has(field));
if (forbiddenProfileFields.length) {
const error = new Error("profile contains forbidden fields");
error.code = "AAS_INPUT_PROFILE_FIELD_FORBIDDEN";
error.details = { fields: forbiddenProfileFields.sort() };
throw error;
}
}
validateInstance(
"recommendation-input.schema.json",
input,
"AAS_INPUT_SCHEMA_INVALID",
"invalidInput",
);
const intent = normalizeToken(input.intent);
if (!Object.hasOwn(ontology.intentAliases, intent)) {
const error = new Error("intent is unsupported in v1");
error.code = "AAS_INPUT_INTENT_UNSUPPORTED";
throw error;
}
const criticalGoals = normalizeStringArray(input.criticalGoals, "criticalGoals");
const nonCriticalGoals = normalizeStringArray(input.nonCriticalGoals, "nonCriticalGoals");
if (criticalGoals.length === 0) {
const error = new Error("at least one critical goal is required");
error.code = "AAS_INPUT_CRITICAL_GOALS_REQUIRED";
throw error;
}
const profile = normalizeProfile(input.profile);
const normalized = {
intent,
targets: normalizeTargets(input.targets),
profile,
criticalGoals,
nonCriticalGoals,
minimumNonCriticalGoalCoverage: Math.max(800, Math.min(1000, Math.round(Number(input.minimumNonCriticalGoalCoverage ?? 0.8) * 1000))),
policy: normalizePolicy(input.policy),
maxSkills: Math.max(1, Math.min(12, Number.isInteger(input.maxSkills) ? input.maxSkills : 6)),
};
normalized.queryTokens = sortedUnique([
...ontology.intentAliases[intent],
...tokenize(intent),
...tokenize(criticalGoals),
...tokenize(nonCriticalGoals),
...tokenize(profile.projectType),
...tokenize(profile.languages),
...tokenize(profile.frameworks),
...tokenize(profile.context),
...tokenize(profile.constraints),
...tokenize(profile.request),
]);
return normalized;
}
module.exports = {
normalizeToken,
compareStrings,
tokenize,
sortedUnique,
normalizeProfile,
normalizePolicy,
normalizeRecommendationInput,
};