4215d49f3f
When HTML/JS contains loginPath or mainPath variables (common in 95598 and similar scenes), extract the domain as expected_domain and the full URL as target_url. This fixes the bootstrap_resolved gate failure for scenes that use loginPath/mainPath instead of meta tags or explicit bootstrap configuration. 🤖 Generated with [Qoder][https://qoder.com]
1403 lines
43 KiB
JavaScript
1403 lines
43 KiB
JavaScript
const fs = require("fs");
|
|
const path = require("path");
|
|
const { spawn } = require("child_process");
|
|
|
|
const TEXT_FILE_EXTENSIONS = new Set([
|
|
".html",
|
|
".js",
|
|
".jsx",
|
|
".json",
|
|
".md",
|
|
".mjs",
|
|
".toml",
|
|
".ts",
|
|
".tsx",
|
|
".txt",
|
|
".vue",
|
|
]);
|
|
|
|
const DEFAULT_BOOTSTRAP = {
|
|
expectedDomain: "",
|
|
targetUrl: "",
|
|
requiresTargetPage: true,
|
|
pageTitleKeywords: [],
|
|
source: "deterministic",
|
|
};
|
|
|
|
const BOOTSTRAP_ROLE_PRIORITY = ["business_entry", "business_api", "gateway_api"];
|
|
|
|
const GENERIC_SCENE_IDS = new Set([
|
|
"scene",
|
|
"report",
|
|
"generated",
|
|
"generated-scene",
|
|
"skill",
|
|
"default-scene",
|
|
]);
|
|
|
|
const GENERIC_SCENE_ID_TOKENS = new Set([
|
|
"api",
|
|
"app",
|
|
"data",
|
|
"default",
|
|
"export",
|
|
"generator",
|
|
"page",
|
|
"report",
|
|
"request",
|
|
"scene",
|
|
"skill",
|
|
"system",
|
|
"table",
|
|
"temp",
|
|
"test",
|
|
"tmp",
|
|
]);
|
|
|
|
const SCENE_ID_ALIAS_RULES = [
|
|
{ pattern: /营销\s*2(?:\.|。)?0/gi, replacement: "marketing" },
|
|
{ pattern: /零度户报表数据生成/gi, replacement: "zero-consumer-report" },
|
|
{ pattern: /零度户报表/gi, replacement: "zero-consumer-report" },
|
|
{ pattern: /零度户/gi, replacement: "zero-consumer" },
|
|
{ pattern: /台区线损率统计分析/gi, replacement: "tq-lineloss-analysis" },
|
|
{ pattern: /台区线损/gi, replacement: "tq-lineloss" },
|
|
{ pattern: /线损率统计分析/gi, replacement: "lineloss-analysis" },
|
|
{ pattern: /线损率/gi, replacement: "lineloss-rate" },
|
|
{ pattern: /线损/gi, replacement: "lineloss" },
|
|
{ pattern: /台区/gi, replacement: "tq" },
|
|
{ pattern: /月[_-]?周累计/gi, replacement: "monthly-weekly-cumulative" },
|
|
{ pattern: /月累计/gi, replacement: "monthly-cumulative" },
|
|
{ pattern: /周累计/gi, replacement: "weekly-cumulative" },
|
|
{ pattern: /统计分析/gi, replacement: "analysis" },
|
|
{ pattern: /报表数据生成/gi, replacement: "report" },
|
|
{ pattern: /报表/gi, replacement: "report" },
|
|
{ pattern: /数据生成/gi, replacement: "generator" },
|
|
];
|
|
|
|
function normalizePath(inputPath) {
|
|
return inputPath.replace(/\\/g, "/");
|
|
}
|
|
|
|
function runGenerator(params, sseWriter, projectRoot) {
|
|
const {
|
|
sourceDir,
|
|
sceneId,
|
|
sceneName,
|
|
sceneKind,
|
|
targetUrl,
|
|
outputRoot,
|
|
lessons,
|
|
sceneInfoJson,
|
|
sceneIrJson,
|
|
completionMeta,
|
|
} = params;
|
|
|
|
const args = [
|
|
"run",
|
|
"--bin",
|
|
"sg_scene_generate",
|
|
"--",
|
|
"--source-dir",
|
|
normalizePath(sourceDir),
|
|
"--scene-id",
|
|
sceneId,
|
|
"--scene-name",
|
|
sceneName,
|
|
];
|
|
|
|
if (sceneKind) {
|
|
args.push("--scene-kind", sceneKind);
|
|
}
|
|
|
|
if (targetUrl) {
|
|
args.push("--target-url", targetUrl);
|
|
}
|
|
|
|
args.push("--output-root", normalizePath(outputRoot));
|
|
|
|
if (lessons) {
|
|
args.push("--lessons", normalizePath(lessons));
|
|
}
|
|
|
|
if (sceneInfoJson) {
|
|
args.push("--scene-info-json", sceneInfoJson);
|
|
}
|
|
|
|
if (sceneIrJson) {
|
|
args.push("--scene-ir-json", sceneIrJson);
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
sseWriter.write(
|
|
`event: status\ndata: ${JSON.stringify({
|
|
message: "Starting skill generation...",
|
|
})}\n\n`
|
|
);
|
|
sseWriter.write(
|
|
`event: status\ndata: ${JSON.stringify({
|
|
message: `Running: cargo ${args.join(" ")}`,
|
|
})}\n\n`
|
|
);
|
|
|
|
const child = spawn("cargo", args, {
|
|
cwd: projectRoot,
|
|
stdio: ["ignore", "pipe", "pipe"],
|
|
env: { ...process.env, RUST_BACKTRACE: "1" },
|
|
});
|
|
|
|
let stdout = "";
|
|
let stderr = "";
|
|
let timedOut = false;
|
|
|
|
const timeout = setTimeout(() => {
|
|
timedOut = true;
|
|
child.kill("SIGTERM");
|
|
sseWriter.write(
|
|
`event: error\ndata: ${JSON.stringify({
|
|
message: "Generation timed out after 5 minutes.",
|
|
})}\n\n`
|
|
);
|
|
resolve({ success: false, error: "timeout" });
|
|
}, 5 * 60 * 1000);
|
|
|
|
child.stdout.on("data", (data) => {
|
|
const text = data.toString();
|
|
stdout += text;
|
|
sseWriter.write(
|
|
`event: log\ndata: ${JSON.stringify({ message: text.trim() })}\n\n`
|
|
);
|
|
});
|
|
|
|
child.stderr.on("data", (data) => {
|
|
const text = data.toString();
|
|
stderr += text;
|
|
sseWriter.write(
|
|
`event: log\ndata: ${JSON.stringify({ message: text.trim() })}\n\n`
|
|
);
|
|
});
|
|
|
|
child.on("close", (code) => {
|
|
clearTimeout(timeout);
|
|
if (timedOut) return;
|
|
|
|
if (code === 0) {
|
|
const match = stdout.match(/generated scene package:\s*(.+)/);
|
|
const skillRoot = match ? match[1] : null;
|
|
sseWriter.write(
|
|
`event: status\ndata: ${JSON.stringify({
|
|
message: "Skill generation completed.",
|
|
})}\n\n`
|
|
);
|
|
sseWriter.write(
|
|
`event: complete\ndata: ${JSON.stringify({
|
|
success: true,
|
|
skillRoot,
|
|
readiness: completionMeta?.readiness || null,
|
|
workflowArchetype: completionMeta?.workflowArchetype || null,
|
|
confidence: completionMeta?.confidence || 0,
|
|
})}\n\n`
|
|
);
|
|
resolve({ success: true, skillRoot });
|
|
} else {
|
|
sseWriter.write(
|
|
`event: error\ndata: ${JSON.stringify({
|
|
message: `Generation failed (exit code ${code})`,
|
|
})}\n\n`
|
|
);
|
|
if (stderr.trim()) {
|
|
sseWriter.write(
|
|
`event: error\ndata: ${JSON.stringify({
|
|
message: stderr.substring(0, 500),
|
|
})}\n\n`
|
|
);
|
|
}
|
|
resolve({ success: false, code, stderr });
|
|
}
|
|
});
|
|
|
|
child.on("error", (err) => {
|
|
clearTimeout(timeout);
|
|
sseWriter.write(
|
|
`event: error\ndata: ${JSON.stringify({
|
|
message: `Failed to start cargo: ${err.message}`,
|
|
})}\n\n`
|
|
);
|
|
reject(err);
|
|
});
|
|
});
|
|
}
|
|
|
|
function readDirectory(sourceDir) {
|
|
if (!fs.existsSync(sourceDir)) {
|
|
throw new Error(`Directory not found: ${sourceDir}`);
|
|
}
|
|
|
|
const stat = fs.statSync(sourceDir);
|
|
if (!stat.isDirectory()) {
|
|
throw new Error(`Not a directory: ${sourceDir}`);
|
|
}
|
|
|
|
const files = [];
|
|
const treeLines = [];
|
|
|
|
walkDirectory(sourceDir, "", files, treeLines);
|
|
|
|
const result = {
|
|
tree: treeLines.join("\n"),
|
|
files,
|
|
};
|
|
|
|
for (const file of files) {
|
|
const baseName = path.basename(file.path);
|
|
if (baseName === "scene.toml") result["scene.toml"] = file.content;
|
|
if (baseName === "SKILL.toml") result["SKILL.toml"] = file.content;
|
|
if (baseName === "SKILL.md") result["SKILL.md"] = file.content;
|
|
if (baseName === "index.html" && !result.indexHtml) result.indexHtml = file.content;
|
|
}
|
|
|
|
const scripts = {};
|
|
for (const file of files) {
|
|
if (file.path.endsWith(".js")) {
|
|
scripts[file.path] = file.content;
|
|
}
|
|
}
|
|
if (Object.keys(scripts).length > 0) {
|
|
result.scripts = scripts;
|
|
}
|
|
|
|
result.analysisContext = buildAnalysisContext(sourceDir, result);
|
|
result.deterministic = buildDeterministicSceneIr(result.analysisContext, sourceDir);
|
|
return result;
|
|
}
|
|
|
|
function walkDirectory(rootDir, relativeDir, files, treeLines) {
|
|
const absoluteDir = relativeDir ? path.join(rootDir, relativeDir) : rootDir;
|
|
const entries = fs
|
|
.readdirSync(absoluteDir, { withFileTypes: true })
|
|
.sort((a, b) => a.name.localeCompare(b.name, "en"));
|
|
|
|
for (const entry of entries) {
|
|
const relativePath = relativeDir
|
|
? path.posix.join(normalizePath(relativeDir), entry.name)
|
|
: entry.name;
|
|
treeLines.push(`${entry.isDirectory() ? "[D]" : "[F]"} ${relativePath}`);
|
|
|
|
if (entry.isDirectory()) {
|
|
walkDirectory(rootDir, relativePath, files, treeLines);
|
|
continue;
|
|
}
|
|
|
|
const ext = path.extname(entry.name).toLowerCase();
|
|
if (!TEXT_FILE_EXTENSIONS.has(ext)) {
|
|
continue;
|
|
}
|
|
|
|
const absolutePath = path.join(absoluteDir, entry.name);
|
|
const stat = fs.statSync(absolutePath);
|
|
if (stat.size > 1024 * 1024) {
|
|
continue;
|
|
}
|
|
|
|
const content = fs.readFileSync(absolutePath, "utf-8");
|
|
files.push({
|
|
path: normalizePath(relativePath),
|
|
content,
|
|
});
|
|
}
|
|
}
|
|
|
|
function buildAnalysisContext(sourceDir, dirContents) {
|
|
const files = Array.isArray(dirContents.files) ? dirContents.files : [];
|
|
const indexHtml = dirContents.indexHtml || "";
|
|
const directorySummary = {
|
|
sourceDir: normalizePath(sourceDir),
|
|
tree: dirContents.tree || "(empty)",
|
|
files: files.map((file) => ({
|
|
path: file.path,
|
|
length: file.content.length,
|
|
})),
|
|
};
|
|
|
|
const THIRD_PARTY_JS_PATTERNS = [
|
|
"vue.js",
|
|
"vue.min.js",
|
|
"element-ui",
|
|
"elementui",
|
|
"axios",
|
|
"jquery",
|
|
"jquery.min.js",
|
|
"echarts",
|
|
"echarts.min.js",
|
|
];
|
|
|
|
const dirFiles = dirContents.files || [];
|
|
const businessJsFragments = [];
|
|
for (const file of dirFiles) {
|
|
if (!file.path.startsWith("js/") || !file.path.endsWith(".js")) continue;
|
|
const baseName = path.basename(file.path).toLowerCase();
|
|
if (THIRD_PARTY_JS_PATTERNS.some((pattern) => baseName.includes(pattern))) continue;
|
|
businessJsFragments.push({
|
|
path: file.path,
|
|
snippet: file.content.length > 600 ? file.content.slice(0, 600) : file.content,
|
|
});
|
|
}
|
|
|
|
return {
|
|
directorySummary,
|
|
indexHtmlChunks: chunkFile("index.html", indexHtml, 3000, 2),
|
|
urlFragments: collectFragments(files, isUrlFragment, 10),
|
|
requestFragments: collectFragments(files, isRequestFragment, 10),
|
|
branchingFragments: collectFragments(files, isBranchFragment, 8),
|
|
responseFragments: collectFragments(files, isResponseFragment, 8),
|
|
exportFragments: collectFragments(files, isExportFragment, 6),
|
|
bootstrapHints: collectBootstrapHints(files, indexHtml),
|
|
deterministicSignals: collectDeterministicSignals(files, indexHtml),
|
|
businessJsFragments,
|
|
};
|
|
}
|
|
|
|
function chunkFile(filePath, content, chunkSize, maxChunks) {
|
|
if (!content) return [];
|
|
const chunks = [];
|
|
let index = 0;
|
|
let offset = 0;
|
|
while (offset < content.length && chunks.length < maxChunks) {
|
|
chunks.push({
|
|
path: filePath,
|
|
index,
|
|
start: offset,
|
|
end: Math.min(offset + chunkSize, content.length),
|
|
content: content.slice(offset, offset + chunkSize),
|
|
});
|
|
index += 1;
|
|
offset += chunkSize;
|
|
}
|
|
return chunks;
|
|
}
|
|
|
|
function collectFragments(files, predicate, limit) {
|
|
const fragments = [];
|
|
for (const file of files) {
|
|
const fileFragments = extractLineFragments(file.path, file.content, predicate, limit - fragments.length);
|
|
fragments.push(...fileFragments);
|
|
if (fragments.length >= limit) {
|
|
break;
|
|
}
|
|
}
|
|
return fragments;
|
|
}
|
|
|
|
function extractLineFragments(filePath, content, predicate, remainingLimit) {
|
|
if (!content || remainingLimit <= 0) return [];
|
|
const fragments = [];
|
|
const lines = content.split(/\r?\n/);
|
|
const seen = new Set();
|
|
|
|
for (let i = 0; i < lines.length && fragments.length < remainingLimit; i += 1) {
|
|
if (!predicate(lines[i])) continue;
|
|
const start = Math.max(0, i - 3);
|
|
const end = Math.min(lines.length, i + 4);
|
|
const snippet = lines.slice(start, end).join("\n").trim();
|
|
if (!snippet || seen.has(snippet)) continue;
|
|
seen.add(snippet);
|
|
fragments.push({
|
|
path: filePath,
|
|
lineStart: start + 1,
|
|
lineEnd: end,
|
|
snippet: snippet.length > 1200 ? snippet.slice(0, 1200) : snippet,
|
|
});
|
|
}
|
|
|
|
return fragments;
|
|
}
|
|
|
|
function isUrlFragment(line) {
|
|
return /(https?:\/\/|['"`]\/[^'"`\s]+|url\s*:|fetch\s*\(|axios\.(get|post|request)|\$\.(ajax|get|post))/i.test(line);
|
|
}
|
|
|
|
function isRequestFragment(line) {
|
|
return /(contentType|JSON\.stringify|requestBody|requestData|payload|params|data\s*:|body\s*:|FormData|\bpage(Size|No)?\b|\brows\b)/i.test(line);
|
|
}
|
|
|
|
function isBranchFragment(line) {
|
|
return /\b(if|else if|switch|case)\b/.test(line) && /(mode|period|reportType|tab|status|scene|type)/i.test(line);
|
|
}
|
|
|
|
function isResponseFragment(line) {
|
|
return /(response|res|result)\.(data|content|rows|list|records|items)|\.map\(|\.filter\(|columnDefs|columns|normalize|transform/i.test(line);
|
|
}
|
|
|
|
function isExportFragment(line) {
|
|
return /(export|download|xlsx|csv|blob|saveAs|excel)/i.test(line);
|
|
}
|
|
|
|
function collectBootstrapHints(files, indexHtml) {
|
|
const hints = [];
|
|
const seen = new Set();
|
|
|
|
for (const match of indexHtml.matchAll(/<(a|form|iframe)[^>]+(?:href|action|src)=["']([^"']+)["']/gi)) {
|
|
const url = match[2];
|
|
if (url && !isStaticAssetUrl(url) && !seen.has(url)) {
|
|
seen.add(url);
|
|
hints.push({ type: match[1], url });
|
|
}
|
|
}
|
|
|
|
for (const file of files) {
|
|
const namedUrlMatches = file.content.matchAll(
|
|
/\b(sourceUrl|sourceURL|baseUrl|baseURL|targetUrl|requestUrl|apiUrl|gatewayUrl|loginPath|mainPath)\b\s*[:=]\s*(['"`])(https?:\/\/[^'"`\s]+)\2/gi
|
|
);
|
|
for (const match of namedUrlMatches) {
|
|
const url = match[3];
|
|
const type = String(match[1] || "").toLowerCase();
|
|
if (url && !seen.has(url)) {
|
|
seen.add(url);
|
|
// loginPath/mainPath are bootstrap hints — the domain is expected_domain
|
|
if (type === "loginpath" || type === "mainpath") {
|
|
const domain = new URL(url).hostname;
|
|
hints.push({ type: "expected_domain", value: domain, path: file.path });
|
|
hints.push({ type: "target_url", value: url, path: file.path });
|
|
} else {
|
|
hints.push({ type, url, path: file.path });
|
|
}
|
|
}
|
|
}
|
|
|
|
const matches = file.content.matchAll(/window\.open\((['"`])([^'"`]+)\1|location\.(?:href|assign|replace)\((['"`])([^'"`]+)\3/gi);
|
|
for (const match of matches) {
|
|
const url = match[2] || match[4];
|
|
if (url && !seen.has(url)) {
|
|
seen.add(url);
|
|
hints.push({ type: "navigation", url, path: file.path });
|
|
}
|
|
}
|
|
}
|
|
|
|
return hints.slice(0, 12);
|
|
}
|
|
|
|
function collectDeterministicSignals(files, indexHtml) {
|
|
const urls = new Map();
|
|
const methods = new Map();
|
|
const responsePaths = new Set();
|
|
const branchFields = new Set();
|
|
const modeValues = new Set();
|
|
const paginationVars = new Set();
|
|
const filterExpressions = new Set();
|
|
const entryMethods = new Set();
|
|
const exportMethods = new Set();
|
|
const secondaryRequestMethods = new Set();
|
|
const pageTitleKeywords = new Set();
|
|
const staticParams = {};
|
|
|
|
for (const file of files) {
|
|
const content = file.content;
|
|
|
|
for (const endpoint of extractEndpoints(content)) {
|
|
const key = `${endpoint.method}|${endpoint.url}`;
|
|
if (!urls.has(key)) {
|
|
urls.set(key, endpoint);
|
|
}
|
|
}
|
|
|
|
for (const match of content.matchAll(/\b(type|method)\s*:\s*['"`](GET|POST|PUT|DELETE|PATCH)['"`]/gi)) {
|
|
methods.set(match[2].toUpperCase(), true);
|
|
}
|
|
|
|
for (const match of content.matchAll(/\b(?:response|res|result)\.(data|content|rows|list|records|items)\b/g)) {
|
|
responsePaths.add(match[1]);
|
|
}
|
|
|
|
for (const match of content.matchAll(/\b(?:if|switch|case)\b[\s\S]{0,120}?(period_mode|reportType|mode|tab|sceneType|status|type)\b/gi)) {
|
|
branchFields.add(match[1]);
|
|
}
|
|
|
|
for (const match of content.matchAll(/\b(period_mode|reportType|mode|tab)\b[\s\S]{0,80}?['"`](month|week|day|detail|summary|list|chart)['"`]/gi)) {
|
|
modeValues.add(match[2]);
|
|
}
|
|
|
|
for (const match of content.matchAll(/\b(pageSize|pageNo|pageNum|page|rows|limit|offset)\b/g)) {
|
|
paginationVars.add(match[1]);
|
|
}
|
|
|
|
for (const match of content.matchAll(/\.filter\(\s*(.+?)\s*\)|if\s*\(([^)]*(?:!==|!=|===|==|>|<)[^)]*)\)/g)) {
|
|
const expr = (match[1] || match[2] || "").trim();
|
|
if (expr && expr.length <= 160) {
|
|
filterExpressions.add(expr);
|
|
}
|
|
}
|
|
|
|
for (const match of content.matchAll(/(?:function\s+|const\s+|let\s+|var\s+)([A-Za-z_$][\w$]*)\s*(?:=\s*(?:async\s*)?\(|\()/g)) {
|
|
const name = match[1];
|
|
if (/(query|search|load|fetch|init|mounted|created|getData)/i.test(name)) {
|
|
entryMethods.add(name);
|
|
}
|
|
if (/(export|download|excel|csv)/i.test(name)) {
|
|
exportMethods.add(name);
|
|
}
|
|
if (/(detail|charge|charges|info|details)/i.test(name)) {
|
|
secondaryRequestMethods.add(name);
|
|
}
|
|
}
|
|
|
|
for (const match of content.matchAll(/(?:title|document\.title)\s*[:=]\s*['"`]([^'"`]{2,40})['"`]/gi)) {
|
|
pageTitleKeywords.add(match[1]);
|
|
}
|
|
|
|
const staticParamMatches = content.matchAll(/\b(orgNo|orgCode|orgId|period_mode|reportType|pageSize|rows)\b\s*:\s*['"`]([^'"`\n]+)['"`]/gi);
|
|
for (const match of staticParamMatches) {
|
|
if (!(match[1] in staticParams)) {
|
|
staticParams[match[1]] = match[2];
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const match of indexHtml.matchAll(/<title>([^<]{2,40})<\/title>/gi)) {
|
|
pageTitleKeywords.add(match[1].trim());
|
|
}
|
|
|
|
const bootstrapCandidates = collectBootstrapCandidates(files, indexHtml, Array.from(urls.values()));
|
|
return {
|
|
endpoints: Array.from(urls.values()),
|
|
methods: Array.from(methods.keys()),
|
|
responsePaths: Array.from(responsePaths),
|
|
branchFields: Array.from(branchFields),
|
|
modeValues: Array.from(modeValues),
|
|
paginationVars: Array.from(paginationVars),
|
|
filterExpressions: Array.from(filterExpressions).slice(0, 8),
|
|
entryMethods: Array.from(entryMethods).slice(0, 10),
|
|
exportMethods: Array.from(exportMethods).slice(0, 10),
|
|
secondaryRequestMethods: Array.from(secondaryRequestMethods).slice(0, 10),
|
|
pageTitleKeywords: Array.from(pageTitleKeywords).slice(0, 10),
|
|
staticParams,
|
|
bootstrapCandidates,
|
|
};
|
|
}
|
|
|
|
function extractEndpoints(content) {
|
|
const endpoints = [];
|
|
const seen = new Set();
|
|
const lines = content.split(/\r?\n/);
|
|
|
|
for (let index = 0; index < lines.length; index += 1) {
|
|
const line = lines[index];
|
|
if (!isUrlFragment(line)) continue;
|
|
|
|
const block = lines.slice(Math.max(0, index - 2), Math.min(lines.length, index + 5)).join("\n");
|
|
const urlMatch =
|
|
block.match(/\burl\s*:\s*(['"`])([^'"`]+)\1/i) ||
|
|
block.match(/fetch\s*\(\s*(['"`])([^'"`]+)\1/i) ||
|
|
block.match(/axios\.(?:get|post|request)\s*\(\s*(['"`])([^'"`]+)\1/i);
|
|
|
|
if (!urlMatch) continue;
|
|
|
|
const url = sanitizeUrl(urlMatch[2]);
|
|
if (!url) continue;
|
|
|
|
const methodMatch =
|
|
block.match(/\b(?:type|method)\s*:\s*(['"`])([A-Z]+)\1/i) ||
|
|
block.match(/\baxios\.post\s*\(/i) ||
|
|
block.match(/\baxios\.get\s*\(/i);
|
|
const method = methodMatch
|
|
? String(methodMatch[2] || (methodMatch[0].includes(".post") ? "POST" : "GET")).toUpperCase()
|
|
: "GET";
|
|
const contentTypeMatch = block.match(/\bcontentType\s*:\s*(['"`])([^'"`]+)\1/i);
|
|
const name = inferEndpointName(block, url, endpoints.length);
|
|
const role = classifyRequestRole(url);
|
|
const key = `${method}|${url}`;
|
|
if (seen.has(key)) continue;
|
|
seen.add(key);
|
|
endpoints.push({
|
|
name,
|
|
url,
|
|
role,
|
|
method,
|
|
contentType: contentTypeMatch ? contentTypeMatch[2] : null,
|
|
description: `Detected from source snippet around line ${index + 1}`,
|
|
});
|
|
}
|
|
|
|
return endpoints.slice(0, 12);
|
|
}
|
|
|
|
function sanitizeUrl(rawUrl) {
|
|
if (!rawUrl) return "";
|
|
const value = rawUrl.trim();
|
|
if (!value) return "";
|
|
if (isStaticAssetUrl(value)) return "";
|
|
if (isTemplateNoiseUrl(value)) return "";
|
|
if (/^(javascript:|data:|#)/i.test(value)) return "";
|
|
if (/\.js(\?|$)|\.css(\?|$)|\.png(\?|$)|\.svg(\?|$)/i.test(value)) return "";
|
|
return value;
|
|
}
|
|
|
|
function classifyRequestRole(rawUrl) {
|
|
const value = String(rawUrl || "").toLowerCase();
|
|
if (!value || isTemplateNoiseUrl(value)) return "template_noise";
|
|
if (value.includes("localhost") || value.includes("127.0.0.1")) {
|
|
return /(surfaceservices|reportservices|export)/i.test(value) ? "export_service" : "local_helper";
|
|
}
|
|
if (value.includes("gateway")) return "gateway_api";
|
|
return "business_api";
|
|
}
|
|
|
|
function inferEndpointName(block, url, index) {
|
|
const functionMatch = block.match(/(?:function|const|let|var)\s+([A-Za-z_$][\w$]*)/);
|
|
if (functionMatch) return functionMatch[1];
|
|
const pathParts = url.split(/[/?#]/).filter(Boolean);
|
|
return pathParts[pathParts.length - 1] || `endpoint_${index + 1}`;
|
|
}
|
|
|
|
function collectBootstrapCandidates(files, indexHtml, endpoints) {
|
|
const candidates = [];
|
|
const seen = new Set();
|
|
|
|
for (const endpoint of endpoints) {
|
|
const candidate = buildBootstrapCandidate(endpoint.url, "api_endpoint");
|
|
const key = candidate ? `${candidate.role}|${candidate.targetUrl}` : "";
|
|
if (candidate && !seen.has(key)) {
|
|
seen.add(key);
|
|
candidates.push(candidate);
|
|
}
|
|
}
|
|
|
|
for (const hint of collectBootstrapHints(files, indexHtml)) {
|
|
const candidate = buildBootstrapCandidate(hint.url, hint.type);
|
|
const key = candidate ? `${candidate.role}|${candidate.targetUrl}` : "";
|
|
if (candidate && !seen.has(key)) {
|
|
seen.add(key);
|
|
candidates.push(candidate);
|
|
}
|
|
}
|
|
|
|
return candidates.slice(0, 8);
|
|
}
|
|
|
|
function buildBootstrapCandidate(rawUrl, source) {
|
|
if (!rawUrl) return null;
|
|
try {
|
|
const url = new URL(rawUrl, "http://placeholder.local");
|
|
const role = classifyBootstrapRole(rawUrl, source, url);
|
|
if (!role) {
|
|
return null;
|
|
}
|
|
const isAbsolute = /^https?:\/\//i.test(rawUrl);
|
|
const targetUrl = isAbsolute
|
|
? role === "business_api" || role === "gateway_api"
|
|
? url.origin
|
|
: `${url.origin}${url.pathname}`
|
|
: rawUrl;
|
|
return {
|
|
expectedDomain: isAbsolute ? url.hostname : "",
|
|
targetUrl,
|
|
source,
|
|
role,
|
|
validForBootstrap: BOOTSTRAP_ROLE_PRIORITY.includes(role),
|
|
};
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function classifyBootstrapRole(rawUrl, source, parsedUrl) {
|
|
const value = String(rawUrl || "").trim();
|
|
if (!value || isTemplateNoiseUrl(value)) return "template_noise";
|
|
if (isStaticAssetUrl(value)) return "static_asset";
|
|
if (/^(javascript:|data:|#)/i.test(value)) return "template_noise";
|
|
|
|
const isAbsolute = /^https?:\/\//i.test(value);
|
|
if (!isAbsolute) {
|
|
return value.startsWith("/") ? "business_entry" : "template_noise";
|
|
}
|
|
|
|
const hostname = String(parsedUrl?.hostname || "").toLowerCase();
|
|
const pathname = String(parsedUrl?.pathname || "");
|
|
if (hostname === "localhost" || hostname === "127.0.0.1") {
|
|
if (/(SurfaceServices|ReportServices|export)/i.test(pathname)) {
|
|
return "export_service";
|
|
}
|
|
return "local_helper";
|
|
}
|
|
if (/(gateway)/i.test(hostname) || /(gateway)/i.test(value)) {
|
|
return "gateway_api";
|
|
}
|
|
if (/(sourceurl|targeturl|navigation|form|iframe|a)/i.test(source)) {
|
|
return "business_entry";
|
|
}
|
|
if (/(apiurl|requesturl|baseurl|api_endpoint)/i.test(source) || /\/api\//i.test(pathname)) {
|
|
return "business_api";
|
|
}
|
|
return "business_entry";
|
|
}
|
|
|
|
function isTemplateNoiseUrl(rawUrl) {
|
|
return /\$\{[^}]+\}|%s|placeholder|not a valid/i.test(rawUrl);
|
|
}
|
|
|
|
function isStaticAssetUrl(rawUrl) {
|
|
return /(?:cdn|static|assets?)|(?:\.js|\.css|\.png|\.jpg|\.jpeg|\.gif|\.svg|\.ico)(?:\?|$)/i.test(rawUrl);
|
|
}
|
|
|
|
function buildDeterministicSceneIr(context, sourceDir) {
|
|
const signals = context.deterministicSignals || {};
|
|
const sceneName = humanizeSceneName(path.basename(sourceDir));
|
|
const sceneIdDiagnostics = deriveSceneIdDiagnostics({ sourceDir, sceneName, signals });
|
|
const sceneId = sceneIdDiagnostics.selected || "";
|
|
const workflowArchetype = classifyWorkflowArchetype(signals);
|
|
const evidence = buildEvidence(signals, workflowArchetype);
|
|
const bootstrap = deriveBootstrap(signals);
|
|
const modes = buildModes(signals);
|
|
const workflowSteps = buildWorkflowSteps(signals, workflowArchetype);
|
|
const workflowEvidence = buildWorkflowEvidence(signals);
|
|
const responsePath = signals.responsePaths?.[0] || "";
|
|
const normalizeRules = buildNormalizeRules(signals);
|
|
const params = buildParams(signals, workflowArchetype);
|
|
const confidence = scoreConfidence(signals, workflowArchetype);
|
|
const readiness = buildReadiness({
|
|
sceneIdDiagnostics,
|
|
workflowArchetype,
|
|
bootstrap,
|
|
apiEndpoints: signals.endpoints || [],
|
|
params,
|
|
workflowSteps,
|
|
confidence,
|
|
});
|
|
|
|
return {
|
|
sceneId,
|
|
sceneIdDiagnostics,
|
|
sceneName,
|
|
sceneKind: "report_collection",
|
|
workflowArchetype,
|
|
bootstrap,
|
|
params,
|
|
modes,
|
|
defaultMode: modes[0] ? modes[0].name : null,
|
|
modeSwitchField: signals.branchFields?.find((field) => /mode|period/i.test(field)) || null,
|
|
workflowSteps,
|
|
workflowEvidence,
|
|
requestTemplate: {},
|
|
responsePath,
|
|
normalizeRules,
|
|
artifactContract: {
|
|
type: "report-artifact",
|
|
successStatus: ["ok", "partial", "empty"],
|
|
failureStatus: ["blocked", "error"],
|
|
},
|
|
validationHints: {
|
|
requiresTargetPage: true,
|
|
runtimeCompatible: params.every((param) =>
|
|
["dictionary_entity", "month_week_period", "literal_passthrough", "fixed_enum"].includes(param.resolver)
|
|
),
|
|
manualCompletionRequired: readiness.level !== "A",
|
|
missingPieces: readiness.missingPieces.slice(),
|
|
},
|
|
evidence,
|
|
readiness,
|
|
apiEndpoints: signals.endpoints || [],
|
|
staticParams: signals.staticParams || {},
|
|
columnDefs: [],
|
|
confidence,
|
|
uncertainties: buildUncertainties(signals, workflowArchetype),
|
|
deterministicSignals: signals,
|
|
};
|
|
}
|
|
|
|
function deriveSceneIdDiagnostics({ sourceDir, sceneName, signals }) {
|
|
const baseName = path.basename(sourceDir || "");
|
|
const candidates = [];
|
|
const seen = new Set();
|
|
|
|
function pushCandidate(value, source) {
|
|
const normalized = slugifyAscii(value);
|
|
if (!normalized || seen.has(normalized)) return;
|
|
seen.add(normalized);
|
|
const validation = validateSceneIdCandidate(normalized, { sceneName, sourceDir, signals });
|
|
candidates.push({
|
|
value: normalized,
|
|
source,
|
|
valid: validation.valid,
|
|
reason: validation.valid ? null : validation.reason,
|
|
});
|
|
}
|
|
|
|
pushCandidate(buildKeywordSceneId(baseName, sceneName, signals), "deterministic_keywords");
|
|
pushCandidate(buildAliasSceneId(baseName), "controlled_alias");
|
|
pushCandidate(slugifyAscii(baseName), "directory_slug");
|
|
|
|
const selectedCandidate = candidates.find((candidate) => candidate.valid) || candidates[0] || null;
|
|
return {
|
|
selected: selectedCandidate?.value || "",
|
|
candidateSource: selectedCandidate?.source || "",
|
|
valid: Boolean(selectedCandidate?.valid),
|
|
invalidReason: selectedCandidate && !selectedCandidate.valid ? selectedCandidate.reason : null,
|
|
candidates,
|
|
};
|
|
}
|
|
|
|
function buildKeywordSceneId(baseName, sceneName, signals) {
|
|
const aliasedCandidates = Array.from(
|
|
new Set(
|
|
[baseName, sceneName]
|
|
.filter(Boolean)
|
|
.map((value) => slugifyAscii(applySceneIdAliases(value)))
|
|
.filter(Boolean)
|
|
)
|
|
).sort((left, right) => right.length - left.length);
|
|
const aliased = aliasedCandidates[0] || "";
|
|
if (aliased && aliased.split("-").length >= 2) {
|
|
return aliased;
|
|
}
|
|
const tokens = extractBusinessTokens(
|
|
[baseName, sceneName]
|
|
.filter(Boolean)
|
|
.join(" "),
|
|
signals
|
|
);
|
|
if (!tokens.length) return "";
|
|
return tokens.slice(0, 5).join("-");
|
|
}
|
|
|
|
function buildAliasSceneId(baseName) {
|
|
if (!baseName) return "";
|
|
let value = String(baseName || "");
|
|
for (const rule of SCENE_ID_ALIAS_RULES) {
|
|
value = value.replace(rule.pattern, ` ${rule.replacement} `);
|
|
}
|
|
return slugifyAscii(value);
|
|
}
|
|
|
|
function extractBusinessTokens(rawText, signals = {}) {
|
|
const candidates = [];
|
|
const pushTokens = (value) => {
|
|
const slug = slugifyAscii(value);
|
|
if (!slug) return;
|
|
for (const token of slug.split("-")) {
|
|
if (!token || token.length < 2 || GENERIC_SCENE_ID_TOKENS.has(token)) continue;
|
|
candidates.push(token);
|
|
}
|
|
};
|
|
|
|
pushTokens(applySceneIdAliases(rawText));
|
|
|
|
for (const keyword of signals.pageTitleKeywords || []) {
|
|
pushTokens(applySceneIdAliases(keyword));
|
|
}
|
|
|
|
for (const endpoint of signals.endpoints || []) {
|
|
pushTokens(endpoint?.name);
|
|
const urlValue = String(endpoint?.url || "");
|
|
const segments = urlValue
|
|
.split(/[/?#=&._-]+/)
|
|
.filter(Boolean)
|
|
.slice(-4);
|
|
for (const segment of segments) {
|
|
pushTokens(segment);
|
|
}
|
|
}
|
|
|
|
return Array.from(new Set(candidates));
|
|
}
|
|
|
|
function applySceneIdAliases(value) {
|
|
let text = String(value || "");
|
|
for (const rule of SCENE_ID_ALIAS_RULES) {
|
|
text = text.replace(rule.pattern, ` ${rule.replacement} `);
|
|
}
|
|
return text;
|
|
}
|
|
|
|
function validateSceneIdCandidate(sceneId, { sceneName = "", sourceDir = "", signals = {} } = {}) {
|
|
const normalized = slugifyAscii(sceneId);
|
|
if (!normalized) {
|
|
return { valid: false, reason: "empty_scene_id" };
|
|
}
|
|
if (GENERIC_SCENE_IDS.has(normalized)) {
|
|
return { valid: false, reason: "generic_scene_id" };
|
|
}
|
|
|
|
const letters = (normalized.match(/[a-z]/g) || []).length;
|
|
const digits = (normalized.match(/\d/g) || []).length;
|
|
if (!letters) {
|
|
return { valid: false, reason: "numeric_only_scene_id" };
|
|
}
|
|
if ((normalized.length < 5 || letters < 3) && !normalized.includes("-")) {
|
|
return { valid: false, reason: "scene_id_too_short" };
|
|
}
|
|
if (digits > letters && letters < 4) {
|
|
return { valid: false, reason: "numeric_dominant_scene_id" };
|
|
}
|
|
|
|
const expectedTokens = extractBusinessTokens(
|
|
[sceneName, path.basename(sourceDir || "")]
|
|
.filter(Boolean)
|
|
.join(" "),
|
|
signals
|
|
).filter((token) => token.length >= 3);
|
|
if (expectedTokens.length) {
|
|
const matched = expectedTokens.some((token) => normalized.includes(token));
|
|
if (!matched) {
|
|
return { valid: false, reason: "scene_id_semantic_detached" };
|
|
}
|
|
}
|
|
|
|
return { valid: true, reason: null };
|
|
}
|
|
|
|
function classifyWorkflowArchetype(signals) {
|
|
const businessEndpoints = getBusinessEndpoints(signals);
|
|
const hasPagination = (signals.paginationVars || []).length > 0;
|
|
const hasSecondaryRequest =
|
|
(signals.secondaryRequestMethods || []).length > 0 || businessEndpoints.length >= 2;
|
|
const hasPostProcess =
|
|
(signals.filterExpressions || []).length > 0 || (signals.exportMethods || []).length > 0;
|
|
if (hasPagination && hasSecondaryRequest && hasPostProcess) {
|
|
return "paginated_enrichment";
|
|
}
|
|
|
|
const hasModeBranch = (signals.branchFields || []).some((field) => /period_mode|reportType|tjzq|mode/i.test(field));
|
|
const hasModeValues = (signals.modeValues || []).length >= 2;
|
|
const hasModeDivergence = hasModeValues && businessEndpoints.length >= 2;
|
|
if (hasModeBranch && hasModeDivergence) {
|
|
return "multi_mode_request";
|
|
}
|
|
|
|
const pageStateSignals = [...(signals.entryMethods || []), ...(signals.filterExpressions || [])].join(" ");
|
|
if (/(state|status|ready|available|enabled)/i.test(pageStateSignals) && businessEndpoints.length <= 1) {
|
|
return "page_state_eval";
|
|
}
|
|
|
|
return "single_request_table";
|
|
}
|
|
|
|
function buildEvidence(signals, workflowArchetype) {
|
|
const evidence = [];
|
|
const businessEndpoints = getBusinessEndpoints(signals);
|
|
|
|
if (businessEndpoints.length > 0) {
|
|
evidence.push({
|
|
kind: "deterministic",
|
|
summary: `Detected ${businessEndpoints.length} business API endpoint(s).`,
|
|
source: "runner",
|
|
confidence: 0.9,
|
|
});
|
|
}
|
|
|
|
if ((signals.branchFields || []).length > 0) {
|
|
evidence.push({
|
|
kind: "deterministic",
|
|
summary: `Branch fields: ${signals.branchFields.join(", ")}`,
|
|
source: "runner",
|
|
confidence: 0.86,
|
|
});
|
|
}
|
|
|
|
if ((signals.paginationVars || []).length > 0) {
|
|
evidence.push({
|
|
kind: "deterministic",
|
|
summary: `Pagination vars: ${signals.paginationVars.join(", ")}`,
|
|
source: "runner",
|
|
confidence: 0.84,
|
|
});
|
|
}
|
|
|
|
if ((signals.secondaryRequestMethods || []).length > 0) {
|
|
evidence.push({
|
|
kind: "deterministic",
|
|
summary: `Secondary request methods: ${signals.secondaryRequestMethods.join(", ")}`,
|
|
source: "runner",
|
|
confidence: 0.82,
|
|
});
|
|
}
|
|
|
|
if ((signals.exportMethods || []).length > 0) {
|
|
evidence.push({
|
|
kind: "deterministic",
|
|
summary: `Export methods: ${signals.exportMethods.join(", ")}`,
|
|
source: "runner",
|
|
confidence: 0.78,
|
|
});
|
|
}
|
|
|
|
evidence.push({
|
|
kind: "classification",
|
|
summary: `Workflow archetype classified as ${workflowArchetype}.`,
|
|
source: "runner",
|
|
confidence: 0.72,
|
|
});
|
|
|
|
return evidence;
|
|
}
|
|
|
|
function deriveBootstrap(signals) {
|
|
const candidate = BOOTSTRAP_ROLE_PRIORITY
|
|
.map((role) =>
|
|
(signals.bootstrapCandidates || []).find(
|
|
(item) => item.role === role && item.validForBootstrap && item.targetUrl
|
|
)
|
|
)
|
|
.find(Boolean);
|
|
|
|
if (candidate) {
|
|
return {
|
|
expectedDomain: candidate.expectedDomain || "",
|
|
targetUrl: candidate.targetUrl || "",
|
|
requiresTargetPage: true,
|
|
pageTitleKeywords: signals.pageTitleKeywords || [],
|
|
source: candidate.source || "deterministic",
|
|
};
|
|
}
|
|
|
|
return {
|
|
...DEFAULT_BOOTSTRAP,
|
|
pageTitleKeywords: signals.pageTitleKeywords || [],
|
|
};
|
|
}
|
|
|
|
function getBusinessEndpoints(signals) {
|
|
return (signals.endpoints || []).filter((endpoint) =>
|
|
["business_api", "gateway_api", "business_entry"].includes(endpoint.role)
|
|
);
|
|
}
|
|
|
|
function buildModes(signals) {
|
|
const values = (signals.modeValues || []).slice(0, 4);
|
|
if (!values.length) return [];
|
|
|
|
return values.map((value, index) => ({
|
|
name: value,
|
|
label: value,
|
|
condition: {
|
|
field: signals.branchFields?.find((field) => /mode|period|tab|type/i.test(field)) || "period_mode",
|
|
operator: "equals",
|
|
value,
|
|
},
|
|
apiEndpoint: signals.endpoints?.[index] || signals.endpoints?.[0] || null,
|
|
columnDefs: [],
|
|
requestTemplate: {},
|
|
normalizeRules: buildNormalizeRules(signals),
|
|
responsePath: signals.responsePaths?.[0] || "",
|
|
}));
|
|
}
|
|
|
|
function buildWorkflowSteps(signals, workflowArchetype) {
|
|
const steps = [];
|
|
const businessEndpoints = getBusinessEndpoints(signals);
|
|
const primaryEndpoint = businessEndpoints[0]?.name || null;
|
|
const secondaryEndpoint = businessEndpoints[1]?.name || null;
|
|
|
|
if (workflowArchetype === "multi_mode_request") {
|
|
steps.push({
|
|
type: "request",
|
|
entry: signals.entryMethods?.[0] || null,
|
|
endpoint: primaryEndpoint,
|
|
description: "Select mode and query the matching endpoint.",
|
|
});
|
|
steps.push({
|
|
type: "transform",
|
|
description: "Normalize mode-specific rows into a shared artifact.",
|
|
});
|
|
return steps;
|
|
}
|
|
|
|
if (workflowArchetype === "paginated_enrichment") {
|
|
steps.push({
|
|
type: "paginate",
|
|
entry: signals.entryMethods?.[0] || null,
|
|
endpoint: primaryEndpoint,
|
|
description: "Iterate primary list pages.",
|
|
});
|
|
if ((signals.secondaryRequestMethods || []).length > 0 || secondaryEndpoint) {
|
|
steps.push({
|
|
type: "secondary_request",
|
|
entry: signals.secondaryRequestMethods?.[0] || signals.entryMethods?.[1] || null,
|
|
endpoint: secondaryEndpoint,
|
|
description: "Fetch per-row or batched detail data.",
|
|
});
|
|
}
|
|
if (signals.filterExpressions?.[0]) {
|
|
steps.push({
|
|
type: "filter",
|
|
expr: signals.filterExpressions[0],
|
|
description: "Apply business-side filtering.",
|
|
});
|
|
}
|
|
if (signals.exportMethods?.[0]) {
|
|
steps.push({
|
|
type: "export",
|
|
entry: signals.exportMethods[0],
|
|
description: "Prepare export payload or trigger download logic.",
|
|
});
|
|
}
|
|
return steps;
|
|
}
|
|
|
|
if (workflowArchetype === "page_state_eval") {
|
|
steps.push({
|
|
type: "page_state",
|
|
entry: signals.entryMethods?.[0] || null,
|
|
description: "Evaluate page state and derive readiness outcome.",
|
|
});
|
|
return steps;
|
|
}
|
|
|
|
steps.push({
|
|
type: "request",
|
|
entry: signals.entryMethods?.[0] || null,
|
|
endpoint: primaryEndpoint,
|
|
description: "Issue the primary scene request.",
|
|
});
|
|
steps.push({
|
|
type: "transform",
|
|
description: "Normalize the primary response.",
|
|
});
|
|
return steps;
|
|
}
|
|
|
|
function buildNormalizeRules(signals) {
|
|
return {
|
|
type: "validate_required",
|
|
requiredFields: [],
|
|
filterNull: true,
|
|
responseHints: signals.responsePaths || [],
|
|
};
|
|
}
|
|
|
|
function buildWorkflowEvidence(signals) {
|
|
return {
|
|
requestEntries: uniqueStringValues([
|
|
...(signals.entryMethods || []).slice(0, 3),
|
|
...getBusinessEndpoints(signals).map((endpoint) => endpoint.name).slice(0, 3),
|
|
]),
|
|
paginationFields: uniqueStringValues(signals.paginationVars || []),
|
|
secondaryRequestEntries: uniqueStringValues([
|
|
...(signals.secondaryRequestMethods || []),
|
|
...getBusinessEndpoints(signals).slice(1, 3).map((endpoint) => endpoint.name),
|
|
]),
|
|
postProcessSteps: uniqueStringValues([
|
|
...(signals.filterExpressions || []).map(() => "filter"),
|
|
...(signals.exportMethods || []).map(() => "export"),
|
|
]),
|
|
};
|
|
}
|
|
|
|
function buildParams(signals, workflowArchetype) {
|
|
const params = [];
|
|
const staticKeys = Object.keys(signals.staticParams || {});
|
|
|
|
if (staticKeys.some((key) => /org/i.test(key)) || workflowArchetype === "multi_mode_request") {
|
|
params.push({
|
|
name: "org",
|
|
resolver: "dictionary_entity",
|
|
required: true,
|
|
promptMissing: "Organization parameter is missing.",
|
|
promptAmbiguous: "Organization parameter is ambiguous.",
|
|
resolverConfig: {},
|
|
});
|
|
}
|
|
|
|
if (
|
|
(signals.branchFields || []).some((field) => /period|mode/i.test(field)) ||
|
|
staticKeys.some((key) => /period/i.test(key))
|
|
) {
|
|
params.push({
|
|
name: "period",
|
|
resolver: "month_week_period",
|
|
required: true,
|
|
promptMissing: "Period parameter is missing.",
|
|
promptAmbiguous: "Period parameter is ambiguous.",
|
|
resolverConfig: {},
|
|
});
|
|
}
|
|
|
|
if ((signals.paginationVars || []).some((value) => /pageSize|rows|limit/i.test(value))) {
|
|
params.push({
|
|
name: "page_size",
|
|
resolver: "literal_passthrough",
|
|
required: false,
|
|
promptMissing: "",
|
|
promptAmbiguous: "",
|
|
resolverConfig: {},
|
|
});
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
function buildUncertainties(signals, workflowArchetype) {
|
|
const issues = [];
|
|
if (!(signals.endpoints || []).length) {
|
|
issues.push("No API endpoint was detected deterministically.");
|
|
}
|
|
if (!signals.bootstrapCandidates?.some((candidate) => candidate.validForBootstrap)) {
|
|
issues.push("Bootstrap target URL is still inferred weakly.");
|
|
}
|
|
if (workflowArchetype === "paginated_enrichment" && getBusinessEndpoints(signals).length < 2) {
|
|
issues.push("Secondary enrichment request is not strongly confirmed.");
|
|
}
|
|
if (workflowArchetype === "paginated_enrichment" && !(signals.filterExpressions || []).length && !(signals.exportMethods || []).length) {
|
|
issues.push("Paginated enrichment is missing post-process evidence.");
|
|
}
|
|
return issues;
|
|
}
|
|
|
|
function scoreConfidence(signals, workflowArchetype) {
|
|
let score = 0.3;
|
|
if (getBusinessEndpoints(signals).length > 0) score += 0.18;
|
|
if ((signals.bootstrapCandidates || []).some((candidate) => candidate.validForBootstrap)) score += 0.12;
|
|
if ((signals.responsePaths || []).length > 0) score += 0.08;
|
|
if ((signals.entryMethods || []).length > 0) score += 0.06;
|
|
if (workflowArchetype === "multi_mode_request" && (signals.modeValues || []).length >= 2) score += 0.14;
|
|
if (
|
|
workflowArchetype === "paginated_enrichment" &&
|
|
(signals.paginationVars || []).length > 0 &&
|
|
(signals.secondaryRequestMethods || []).length > 0
|
|
) {
|
|
score += 0.14;
|
|
}
|
|
return Math.min(0.95, Number(score.toFixed(2)));
|
|
}
|
|
|
|
function buildReadiness({ sceneIdDiagnostics, workflowArchetype, bootstrap, apiEndpoints, params, workflowSteps, confidence }) {
|
|
const risks = [];
|
|
const missingPieces = [];
|
|
const notes = [];
|
|
const businessApiEndpoints = (apiEndpoints || []).filter((endpoint) =>
|
|
["business_api", "gateway_api", "business_entry"].includes(endpoint.role)
|
|
);
|
|
|
|
if (!sceneIdDiagnostics?.valid) {
|
|
missingPieces.push("invalid_scene_id");
|
|
risks.push(`Scene id is invalid${sceneIdDiagnostics?.invalidReason ? `: ${sceneIdDiagnostics.invalidReason}` : "."}`);
|
|
}
|
|
|
|
if (!bootstrap.targetUrl && !bootstrap.expectedDomain) {
|
|
missingPieces.push("bootstrap_target");
|
|
risks.push("Business bootstrap target is not confirmed.");
|
|
} else if (!bootstrap.expectedDomain) {
|
|
risks.push("Expected domain is missing; host validation may be weak.");
|
|
}
|
|
|
|
if (!businessApiEndpoints.length) {
|
|
missingPieces.push("api_endpoint");
|
|
risks.push("No request endpoint detected.");
|
|
}
|
|
|
|
if (!workflowSteps.length) {
|
|
missingPieces.push("workflow_steps");
|
|
risks.push("Workflow steps are incomplete.");
|
|
}
|
|
|
|
if (workflowArchetype === "paginated_enrichment") {
|
|
const hasPaginate = workflowSteps.some((step) => step.type === "paginate");
|
|
const hasSecondary = workflowSteps.some((step) => step.type === "secondary_request");
|
|
const hasPostProcess = workflowSteps.some((step) => ["filter", "transform", "export"].includes(step.type));
|
|
if (!hasPaginate) {
|
|
missingPieces.push("paginate_step");
|
|
risks.push("Paginated enrichment lacks pagination evidence.");
|
|
}
|
|
if (!hasSecondary || businessApiEndpoints.length < 2) {
|
|
missingPieces.push("secondary_request");
|
|
risks.push("Paginated enrichment lacks a strong secondary request signal.");
|
|
}
|
|
if (!hasPostProcess) {
|
|
missingPieces.push("post_process");
|
|
risks.push("Paginated enrichment lacks filter/transform/export evidence.");
|
|
}
|
|
}
|
|
|
|
if (workflowArchetype === "multi_mode_request" && !params.some((param) => param.name === "period")) {
|
|
risks.push("Mode-aware workflow is missing a resolved period parameter.");
|
|
}
|
|
|
|
if (confidence < 0.55) {
|
|
risks.push("Overall analysis confidence is low.");
|
|
}
|
|
|
|
let level = "A";
|
|
if (missingPieces.length > 0) {
|
|
level = missingPieces.length >= 2 ? "C" : "B";
|
|
} else if (risks.length > 1 || confidence < 0.7) {
|
|
level = "B";
|
|
}
|
|
|
|
if (level === "A") {
|
|
notes.push("Structure looks complete enough for direct trial.");
|
|
} else if (level === "B") {
|
|
notes.push("Generation should be reviewed before internal-network execution.");
|
|
} else {
|
|
notes.push("Manual completion is required before trial.");
|
|
}
|
|
|
|
const gates = [
|
|
{
|
|
name: "scene_id_valid",
|
|
passed: sceneIdDiagnostics?.valid !== false,
|
|
reason: sceneIdDiagnostics?.valid === false ? sceneIdDiagnostics.invalidReason || "invalid_scene_id" : null,
|
|
},
|
|
{
|
|
name: "bootstrap_resolved",
|
|
passed: Boolean(bootstrap.targetUrl || bootstrap.expectedDomain),
|
|
reason: bootstrap.targetUrl || bootstrap.expectedDomain ? null : "bootstrap_target",
|
|
},
|
|
{
|
|
name: "workflow_complete_for_archetype",
|
|
passed: !missingPieces.some((item) =>
|
|
["workflow_steps", "paginate_step", "secondary_request", "post_process"].includes(item)
|
|
),
|
|
reason:
|
|
missingPieces.find((item) =>
|
|
["workflow_steps", "paginate_step", "secondary_request", "post_process"].includes(item)
|
|
) || null,
|
|
},
|
|
{
|
|
name: "runtime_contract_compatible",
|
|
passed: params.every((param) =>
|
|
["dictionary_entity", "month_week_period", "literal_passthrough", "fixed_enum"].includes(param.resolver)
|
|
),
|
|
reason: params.every((param) =>
|
|
["dictionary_entity", "month_week_period", "literal_passthrough", "fixed_enum"].includes(param.resolver)
|
|
)
|
|
? null
|
|
: "runtime_contract_incompatible",
|
|
},
|
|
];
|
|
|
|
return {
|
|
level,
|
|
confidence,
|
|
gates,
|
|
risks,
|
|
missingPieces,
|
|
notes,
|
|
};
|
|
}
|
|
|
|
function slugifyAscii(value) {
|
|
return String(value || "")
|
|
.replace(/([a-z0-9])([A-Z])/g, "$1-$2")
|
|
.trim()
|
|
.toLowerCase()
|
|
.replace(/[^a-z0-9]+/g, "-")
|
|
.replace(/^-+|-+$/g, "");
|
|
}
|
|
|
|
function humanizeSceneName(value) {
|
|
const raw = String(value || "").replace(/[-_]+/g, " ").trim();
|
|
if (!raw) return "Generated Scene";
|
|
return raw.replace(/\b\w/g, (char) => char.toUpperCase());
|
|
}
|
|
|
|
function uniqueStringValues(list) {
|
|
return Array.from(new Set((list || []).filter(Boolean)));
|
|
}
|
|
|
|
module.exports = {
|
|
buildAnalysisContext,
|
|
buildDeterministicSceneIr,
|
|
deriveSceneIdDiagnostics,
|
|
readDirectory,
|
|
runGenerator,
|
|
validateSceneIdCandidate,
|
|
};
|