wehub-resource-sync
634 lines
22 KiB
JavaScript
634 lines
22 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* Generate action tasks from a nav_graph JSON that includes node.actions,
|
|
* and extract ALL reachable trajectories from entry node(s) (home) to each action node.
|
|
*
|
|
* Input: nav_graph JSON produced by scripts/navigation_declaration_analyzer.mjs
|
|
* (with actions enabled), e.g.
|
|
* public/wechatreading_nav_graph_20260112_with_actions.json
|
|
*
|
|
* Output: JSONL file where each line is a task:
|
|
* {
|
|
* "app": "wechat_reading",
|
|
* "taskId": "wechat_reading:settings.reader.autoLock.toggle",
|
|
* "start": { "nodeId": "/" },
|
|
* "target": { "nodeId": "/settings", "routePath": "/settings", "uiStateId": "settings.base" },
|
|
* "trajectories": [
|
|
* { "nodes": [...], "transitions": [...], "length": N },
|
|
* ...
|
|
* ],
|
|
* "trajectoryCount": N,
|
|
* "shortestLength": N,
|
|
* "action": { "id": "...", "label": "...", "behavior": "...", "scope": "...", "paramsSchema": {...} }
|
|
* }
|
|
*/
|
|
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import process from 'node:process';
|
|
import ts from 'typescript';
|
|
|
|
function usage() {
|
|
console.log(`
|
|
Usage:
|
|
node scripts/generate_action_tasks_from_nav_graph.mjs --graph <graph.json> --out <tasks.jsonl>
|
|
|
|
Options:
|
|
--graph <file> Nav graph JSON path (must contain nodes[].actions)
|
|
--out <file> Output JSONL file path
|
|
--limit <n> Limit number of tasks written (default: no limit)
|
|
--start-node <id> Override start nodeId (default: entryPoint nodes)
|
|
--app <AppName> Scan apps/<AppName> to infer action gesture/ui usage (optional)
|
|
--include-unreachable Also output tasks that are unreachable from start (trajectories=[])
|
|
--max-depth <n> Max path length to search (default: 20)
|
|
--max-paths <n> Max number of paths per target node (default: 10)
|
|
--all-paths Enumerate non-shortest paths too (default: shortest paths only)
|
|
`);
|
|
}
|
|
|
|
function parseArgs(argv) {
|
|
const args = argv.slice(2);
|
|
const get = (name) => {
|
|
const idx = args.indexOf(name);
|
|
if (idx === -1) return null;
|
|
return args[idx + 1] ?? null;
|
|
};
|
|
const has = (name) => args.includes(name);
|
|
const graph = get('--graph');
|
|
const out = get('--out');
|
|
const limitRaw = get('--limit');
|
|
const startNode = get('--start-node');
|
|
const app = get('--app');
|
|
const includeUnreachable = has('--include-unreachable');
|
|
const allPaths = has('--all-paths');
|
|
const limit = limitRaw ? Number(limitRaw) : null;
|
|
const maxDepth = get('--max-depth') ? Number(get('--max-depth')) : 20;
|
|
const maxPaths = get('--max-paths') ? Number(get('--max-paths')) : 10;
|
|
return { graph, out, limit, startNode, app, includeUnreachable, allPaths, maxDepth, maxPaths };
|
|
}
|
|
|
|
function readJson(filePath) {
|
|
return JSON.parse(fs.readFileSync(filePath, 'utf8'));
|
|
}
|
|
|
|
function isNodeId(id) {
|
|
return typeof id === 'string' && id.startsWith('/');
|
|
}
|
|
|
|
function buildAdjacency(graph) {
|
|
/** @type {Map<string, Array<any>>} */
|
|
const out = new Map();
|
|
const globalEdges = [];
|
|
|
|
for (const e of graph.edges ?? []) {
|
|
if (e.source === '*') {
|
|
globalEdges.push(e);
|
|
continue;
|
|
}
|
|
if (!isNodeId(e.source)) continue;
|
|
const list = out.get(e.source) ?? [];
|
|
list.push(e);
|
|
out.set(e.source, list);
|
|
}
|
|
|
|
return { out, globalEdges };
|
|
}
|
|
|
|
/**
|
|
* Find ALL paths from start nodes to ALL reachable nodes using BFS.
|
|
* BFS guarantees paths are discovered in order of length (shortest first).
|
|
* Returns a Map<targetNodeId, Array<{nodes, transitions, edges}>>
|
|
*/
|
|
function findAllPaths(graph, startNodeIds, maxDepth, maxPathsPerTarget, { allPaths = false } = {}) {
|
|
const { out, globalEdges } = buildAdjacency(graph);
|
|
|
|
/** @type {Map<string, Array<{nodes: string[], transitions: string[], edges: any[]}>>} */
|
|
const pathsByNode = new Map();
|
|
|
|
// For shortest-only mode: track best (shortest) length discovered for each node.
|
|
/** @type {Map<string, number>} */
|
|
const bestLenByNode = new Map();
|
|
|
|
// Initialize: start nodes have a trivial path (just themselves)
|
|
for (const s of startNodeIds) {
|
|
if (!isNodeId(s)) continue;
|
|
pathsByNode.set(s, [{ nodes: [s], transitions: [], edges: [] }]);
|
|
bestLenByNode.set(s, 0);
|
|
}
|
|
|
|
// BFS queue: each entry is { currentNode, path: {nodes, transitions, edges}, visitedSet }
|
|
const queue = [];
|
|
|
|
// Initialize queue with start nodes
|
|
for (const startNode of startNodeIds) {
|
|
if (!isNodeId(startNode)) continue;
|
|
queue.push({
|
|
currentNode: startNode,
|
|
path: { nodes: [startNode], transitions: [], edges: [] },
|
|
visitedSet: new Set([startNode]),
|
|
});
|
|
}
|
|
|
|
// BFS to find all paths (shortest paths first due to BFS nature)
|
|
while (queue.length > 0) {
|
|
const { currentNode, path, visitedSet } = queue.shift();
|
|
|
|
// Check depth limit
|
|
if (path.nodes.length >= maxDepth) continue;
|
|
|
|
const nextEdges = [
|
|
...(out.get(currentNode) ?? []),
|
|
...globalEdges,
|
|
];
|
|
|
|
for (const e of nextEdges) {
|
|
const nextNode = e?.target;
|
|
if (!isNodeId(nextNode)) continue;
|
|
// Avoid cycles within this path
|
|
if (visitedSet.has(nextNode)) continue;
|
|
|
|
const newPath = {
|
|
nodes: [...path.nodes, nextNode],
|
|
transitions: [...path.transitions, e.id],
|
|
edges: [...path.edges, e],
|
|
};
|
|
const newLen = newPath.transitions.length;
|
|
|
|
// Shortest-only mode: keep only shortest paths for each target node (and all ties).
|
|
if (!allPaths) {
|
|
const best = bestLenByNode.get(nextNode);
|
|
if (best === undefined || newLen < best) {
|
|
bestLenByNode.set(nextNode, newLen);
|
|
pathsByNode.set(nextNode, [newPath]);
|
|
} else if (newLen === best) {
|
|
const existing = pathsByNode.get(nextNode) ?? [];
|
|
if (existing.length < maxPathsPerTarget) {
|
|
existing.push(newPath);
|
|
pathsByNode.set(nextNode, existing);
|
|
} else {
|
|
// cap reached for this node
|
|
}
|
|
} else {
|
|
// longer than best, skip
|
|
continue;
|
|
}
|
|
|
|
// Continue BFS from this path if within cap (even for equal-best, to discover other shortest routes).
|
|
const existingPaths = pathsByNode.get(nextNode) ?? [];
|
|
if (existingPaths.length <= maxPathsPerTarget) {
|
|
const newVisitedSet = new Set(visitedSet);
|
|
newVisitedSet.add(nextNode);
|
|
queue.push({
|
|
currentNode: nextNode,
|
|
path: newPath,
|
|
visitedSet: newVisitedSet,
|
|
});
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// all-paths mode: Store many paths (up to cap), including non-shortest
|
|
const existingPaths = pathsByNode.get(nextNode) ?? [];
|
|
if (existingPaths.length < maxPathsPerTarget) {
|
|
existingPaths.push(newPath);
|
|
pathsByNode.set(nextNode, existingPaths);
|
|
|
|
const newVisitedSet = new Set(visitedSet);
|
|
newVisitedSet.add(nextNode);
|
|
queue.push({
|
|
currentNode: nextNode,
|
|
path: newPath,
|
|
visitedSet: newVisitedSet,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return pathsByNode;
|
|
}
|
|
|
|
/**
|
|
* Get all trajectories for a target node.
|
|
* Returns array of {nodes, transitions, edges, length} sorted by length.
|
|
*/
|
|
function getAllTrajectories(allPathsMap, targetNodeId) {
|
|
const paths = allPathsMap.get(targetNodeId);
|
|
if (!paths || paths.length === 0) return [];
|
|
|
|
return paths
|
|
.map(p => ({
|
|
nodes: p.nodes,
|
|
transitions: p.transitions,
|
|
edges: p.edges,
|
|
length: p.transitions.length,
|
|
}))
|
|
.sort((a, b) => a.length - b.length);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Best-effort: infer action gesture usages from app source code
|
|
// ============================================================================
|
|
|
|
function listFilesRecursive(dir, { exts, ignoreDirs }) {
|
|
const out = [];
|
|
const entries = fs.readdirSync(dir, { withFileTypes: true });
|
|
for (const entry of entries) {
|
|
const full = path.join(dir, entry.name);
|
|
if (entry.isDirectory()) {
|
|
if (ignoreDirs.has(entry.name)) continue;
|
|
out.push(...listFilesRecursive(full, { exts, ignoreDirs }));
|
|
} else {
|
|
const ext = path.extname(entry.name);
|
|
if (exts.has(ext)) out.push(full);
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function createSourceFile(filePath) {
|
|
const text = fs.readFileSync(filePath, 'utf8');
|
|
const ext = path.extname(filePath);
|
|
const kind = ext === '.tsx' ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
|
|
return ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, kind);
|
|
}
|
|
|
|
function getStringLiteralValue(node) {
|
|
if (!node) return null;
|
|
if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
|
|
if (ts.isParenthesizedExpression(node)) return getStringLiteralValue(node.expression);
|
|
if (ts.isAsExpression(node)) return getStringLiteralValue(node.expression);
|
|
return null;
|
|
}
|
|
|
|
function getProp(objLit, name) {
|
|
if (!objLit || !objLit.properties) return null;
|
|
for (const prop of objLit.properties) {
|
|
if (!ts.isPropertyAssignment(prop)) continue;
|
|
const key = prop.name;
|
|
if (ts.isIdentifier(key) && key.text === name) return prop.initializer;
|
|
if (ts.isStringLiteral(key) && key.text === name) return prop.initializer;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function inferActionUiUsages(appDir, declaredActionIds) {
|
|
if (!appDir) return new Map();
|
|
const absDir = path.resolve(appDir);
|
|
if (!fs.existsSync(absDir)) return new Map();
|
|
|
|
const ignoreDirs = new Set(['node_modules', 'dist', 'build']);
|
|
const exts = new Set(['.ts', '.tsx']);
|
|
const files = listFilesRecursive(absDir, { exts, ignoreDirs });
|
|
|
|
/** @type {Map<string, Array<{gestureType:string, kind:string, file:string, line:number, col:number}>>} */
|
|
const out = new Map();
|
|
|
|
const record = (actionId, entry) => {
|
|
if (!declaredActionIds.has(actionId)) return;
|
|
const list = out.get(actionId) ?? [];
|
|
list.push(entry);
|
|
out.set(actionId, list);
|
|
};
|
|
|
|
for (const filePath of files) {
|
|
// Never treat the declaration itself as a "usage" source.
|
|
if (filePath.endsWith(`${path.sep}navigation.declaration.ts`)) continue;
|
|
|
|
const sf = createSourceFile(filePath);
|
|
const rel = path.relative(process.cwd(), filePath);
|
|
|
|
const locOf = (node) => {
|
|
const lc = sf.getLineAndCharacterOfPosition(node.getStart(sf));
|
|
return { file: rel, line: lc.line + 1, col: lc.character + 1 };
|
|
};
|
|
|
|
const extractActionSpecId = (objLit) => {
|
|
if (!objLit || !ts.isObjectLiteralExpression(objLit)) return null;
|
|
const kindVal = getStringLiteralValue(getProp(objLit, 'kind'));
|
|
if (kindVal !== 'action') return null;
|
|
return getStringLiteralValue(getProp(objLit, 'id'));
|
|
};
|
|
|
|
function visit(node) {
|
|
// bindTap/bindLongPress/bindDoubleTap({kind:'action', id:'x'})
|
|
if (ts.isCallExpression(node)) {
|
|
const expr = node.expression;
|
|
const callee =
|
|
ts.isIdentifier(expr) ? expr.text :
|
|
ts.isPropertyAccessExpression(expr) ? expr.name.text :
|
|
null;
|
|
if (callee === 'bindTap' || callee === 'bindLongPress' || callee === 'bindDoubleTap') {
|
|
const first = node.arguments[0];
|
|
if (first && ts.isObjectLiteralExpression(first)) {
|
|
const id = extractActionSpecId(first);
|
|
if (id) {
|
|
const gestureType =
|
|
callee === 'bindTap' ? 'tap' :
|
|
callee === 'bindLongPress' ? 'longPress' :
|
|
'doubleTap';
|
|
record(id, { kind: callee, gestureType, ...locOf(first) });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Best-effort: indirect bindings via shared components (e.g., TopBar right button)
|
|
// We detect any call that passes an object with `id: '<actionId>'`.
|
|
if (ts.isCallExpression(node)) {
|
|
const expr = node.expression;
|
|
const calleeName =
|
|
ts.isIdentifier(expr) ? expr.text :
|
|
ts.isPropertyAccessExpression(expr) ? expr.name.text :
|
|
'call';
|
|
|
|
// Avoid double counting for bind* calls: they are already handled above with accurate gesture type.
|
|
if (calleeName === 'bindTap' || calleeName === 'bindLongPress' || calleeName === 'bindDoubleTap') {
|
|
ts.forEachChild(node, visit);
|
|
return;
|
|
}
|
|
|
|
for (const arg of node.arguments ?? []) {
|
|
if (!arg || !ts.isObjectLiteralExpression(arg)) continue;
|
|
const idInit = getProp(arg, 'id');
|
|
const id = getStringLiteralValue(idInit);
|
|
if (id && declaredActionIds.has(id)) {
|
|
// Gesture type is unknown at analysis time; default to tap for task generation.
|
|
record(id, { kind: calleeName, gestureType: 'tap', ...locOf(idInit ?? arg) });
|
|
}
|
|
}
|
|
}
|
|
|
|
// JSX: data-action="x", plus data-action-type if present (input)
|
|
if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
|
|
const attrs = node.attributes?.properties ?? [];
|
|
let dataAction = null;
|
|
let dataActionType = null;
|
|
for (const a of attrs) {
|
|
if (!ts.isJsxAttribute(a)) continue;
|
|
const name = a.name?.text;
|
|
if (name === 'data-action') {
|
|
const init = a.initializer;
|
|
if (init && ts.isStringLiteral(init)) dataAction = init.text;
|
|
}
|
|
if (name === 'data-action-type') {
|
|
const init = a.initializer;
|
|
if (init && ts.isStringLiteral(init)) dataActionType = init.text;
|
|
}
|
|
}
|
|
if (dataAction && declaredActionIds.has(dataAction)) {
|
|
record(dataAction, { kind: 'data-action', gestureType: dataActionType ?? 'unknown', ...locOf(node) });
|
|
}
|
|
}
|
|
|
|
ts.forEachChild(node, visit);
|
|
}
|
|
visit(sf);
|
|
}
|
|
|
|
// de-dup per actionId
|
|
for (const [id, list] of out.entries()) {
|
|
const seen = new Set();
|
|
const uniq = [];
|
|
for (const x of list) {
|
|
const k = `${x.kind}:${x.gestureType}:${x.file}:${x.line}:${x.col}`;
|
|
if (seen.has(k)) continue;
|
|
seen.add(k);
|
|
uniq.push(x);
|
|
}
|
|
out.set(id, uniq);
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
function pickNodeDetail(node) {
|
|
if (!node) return null;
|
|
return {
|
|
nodeId: node.id,
|
|
routePath: node.routePath,
|
|
uiStateId: node.uiStateId,
|
|
component: node.component,
|
|
description: node.description,
|
|
entryPoint: Boolean(node.entryPoint),
|
|
search: node.search ?? {},
|
|
queryParams: node.queryParams ?? {},
|
|
params: node.params ?? {},
|
|
scrollContainers: node.scrollContainers ?? [],
|
|
stateCondition: node.stateCondition ?? null,
|
|
actionsCount: Array.isArray(node.actions) ? node.actions.length : 0,
|
|
};
|
|
}
|
|
|
|
function pickEdgeDetail(edge) {
|
|
if (!edge) return null;
|
|
return {
|
|
transitionId: edge.id,
|
|
label: edge.label ?? '',
|
|
type: edge.type ?? null,
|
|
mode: edge.mode ?? null,
|
|
source: edge.source,
|
|
target: edge.target,
|
|
uiMeta: edge.uiMeta ?? null,
|
|
uiCondition: edge.uiCondition ?? null,
|
|
fromConstraint: edge.fromConstraint ?? null,
|
|
search: edge.search ?? {},
|
|
searchParams: edge.searchParams ?? {},
|
|
params: edge.params ?? {},
|
|
preserveParams: edge.preserveParams ?? [],
|
|
binding: edge.binding ?? null,
|
|
expandedFrom: edge.expandedFrom ?? null,
|
|
dataSourceRef: edge.dataSourceRef ?? null,
|
|
};
|
|
}
|
|
|
|
function buildDetailedSteps(traj, nodeMap) {
|
|
const detailedSteps = [];
|
|
for (let i = 0; i < traj.edges.length; i++) {
|
|
const fromId = traj.nodes[i];
|
|
const toId = traj.nodes[i + 1];
|
|
const edge = traj.edges[i];
|
|
detailedSteps.push({
|
|
index: i,
|
|
kind: 'transition',
|
|
from: pickNodeDetail(nodeMap.get(fromId)),
|
|
edge: pickEdgeDetail(edge),
|
|
to: pickNodeDetail(nodeMap.get(toId)),
|
|
ui: {
|
|
trigger: {
|
|
dataTrigger: edge?.id ?? null,
|
|
dataTriggerType: edge?.uiMeta?.gesture ?? null,
|
|
paramsSchema: edge?.params ?? {},
|
|
searchParamsSchema: edge?.searchParams ?? {},
|
|
},
|
|
placement: edge?.uiMeta?.placement ?? null,
|
|
icon: edge?.uiMeta?.icon ?? null,
|
|
gesture: edge?.uiMeta?.gesture ?? null,
|
|
},
|
|
});
|
|
}
|
|
return detailedSteps;
|
|
}
|
|
|
|
function main() {
|
|
const { graph: graphPath, out: outPath, limit, startNode, app, includeUnreachable, allPaths, maxDepth, maxPaths } = parseArgs(process.argv);
|
|
if (!graphPath || !outPath) {
|
|
usage();
|
|
process.exit(2);
|
|
}
|
|
|
|
const absGraph = path.resolve(graphPath);
|
|
const absOut = path.resolve(outPath);
|
|
const graph = readJson(absGraph);
|
|
|
|
const nodes = Array.isArray(graph.nodes) ? graph.nodes : [];
|
|
const entryNodes = nodes.filter(n => n?.entryPoint === true).map(n => n.id).filter(isNodeId);
|
|
const startNodeIds = startNode ? [startNode] : entryNodes;
|
|
|
|
if (startNodeIds.length === 0) {
|
|
throw new Error(`No start nodes found. Provide --start-node, or ensure nodes[].entryPoint=true exists in graph.`);
|
|
}
|
|
|
|
console.log(`[ActionTasks] Finding paths (mode=${allPaths ? 'all' : 'shortest'}, maxDepth=${maxDepth}, maxPaths=${maxPaths})...`);
|
|
const allPathsMap = findAllPaths(graph, startNodeIds, maxDepth, maxPaths, { allPaths });
|
|
|
|
// Optional: infer action UI usage from source
|
|
const declaredActionIds = new Set();
|
|
for (const n of nodes) {
|
|
for (const a of (Array.isArray(n?.actions) ? n.actions : [])) {
|
|
if (a?.id && typeof a.id === 'string') declaredActionIds.add(a.id);
|
|
}
|
|
}
|
|
const inferredAppDir = app ? path.join('apps', app) : (graph.appDir ? graph.appDir : null);
|
|
const actionUiUsages = inferActionUiUsages(inferredAppDir, declaredActionIds);
|
|
|
|
const nodeMap = new Map(nodes.map(n => [n.id, n]));
|
|
|
|
const tasks = [];
|
|
let totalTrajectoriesByTargetNode = 0;
|
|
let uniqueActionNodes = 0;
|
|
|
|
for (const n of nodes) {
|
|
const actions = Array.isArray(n?.actions) ? n.actions : [];
|
|
if (actions.length === 0) continue;
|
|
|
|
const nodeId = n.id;
|
|
const trajectories = getAllTrajectories(allPathsMap, nodeId);
|
|
if (trajectories.length === 0 && !includeUnreachable) continue;
|
|
|
|
uniqueActionNodes += 1;
|
|
totalTrajectoriesByTargetNode += trajectories.length;
|
|
|
|
// Build detailed steps for each trajectory
|
|
const trajectoriesDetailed = trajectories.map(traj => {
|
|
const detailedSteps = buildDetailedSteps(traj, nodeMap);
|
|
return {
|
|
nodes: traj.nodes,
|
|
transitions: traj.transitions,
|
|
length: traj.length,
|
|
steps: detailedSteps,
|
|
};
|
|
});
|
|
|
|
for (const a of actions) {
|
|
if (!a?.id || typeof a.id !== 'string') continue;
|
|
const actionUsages = actionUiUsages.get(a.id) ?? [];
|
|
const actionGestureTypes = Array.from(new Set(actionUsages.map(x => x.gestureType))).filter(Boolean);
|
|
const preferredActionGestureType = (() => {
|
|
const known = actionGestureTypes.filter(t => t && t !== 'unknown');
|
|
if (known.includes('tap')) return 'tap';
|
|
if (known.includes('longPress')) return 'longPress';
|
|
if (known.includes('doubleTap')) return 'doubleTap';
|
|
if (known.includes('back')) return 'back';
|
|
return 'tap';
|
|
})();
|
|
|
|
const actionStep = {
|
|
kind: 'action',
|
|
at: pickNodeDetail(n),
|
|
ui: {
|
|
trigger: {
|
|
dataAction: a.id,
|
|
dataActionType: preferredActionGestureType,
|
|
paramsSchema: a.paramsSchema ?? null,
|
|
},
|
|
},
|
|
action: {
|
|
id: a.id,
|
|
label: a.label ?? null,
|
|
description: a.description ?? null,
|
|
behavior: a.behavior ?? null,
|
|
scope: a.scope ?? null,
|
|
paramsSchema: a.paramsSchema ?? null,
|
|
},
|
|
codeUsages: actionUsages.slice(0, 10),
|
|
};
|
|
|
|
// Append action step to each trajectory's steps
|
|
const trajectoriesWithAction = trajectoriesDetailed.map(td => ({
|
|
...td,
|
|
steps: [
|
|
...td.steps,
|
|
{ ...actionStep, index: td.steps.length },
|
|
],
|
|
}));
|
|
|
|
const shortestLength = trajectories.length > 0 ? trajectories[0].length : null;
|
|
|
|
tasks.push({
|
|
app: graph.app ?? null,
|
|
graphFile: path.relative(process.cwd(), absGraph),
|
|
taskId: `${graph.app ?? 'app'}:${a.id}`,
|
|
start: { nodeId: startNodeIds[0] },
|
|
target: { nodeId, routePath: n.routePath, uiStateId: n.uiStateId },
|
|
trajectoryCount: trajectories.length,
|
|
shortestLength,
|
|
trajectories: trajectories.map(t => ({ nodes: t.nodes, transitions: t.transitions, length: t.length })),
|
|
trajectoriesDetailed: trajectoriesWithAction,
|
|
action: {
|
|
id: a.id,
|
|
label: a.label ?? null,
|
|
description: a.description ?? null,
|
|
behavior: a.behavior ?? null,
|
|
scope: a.scope ?? null,
|
|
paramsSchema: a.paramsSchema ?? null,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
// Stable order: reachable first (shorter first), then by taskId.
|
|
tasks.sort((x, y) => {
|
|
const ax = x.shortestLength ?? 1e9;
|
|
const ay = y.shortestLength ?? 1e9;
|
|
if (ax !== ay) return ax - ay;
|
|
return String(x.taskId).localeCompare(String(y.taskId));
|
|
});
|
|
|
|
const finalTasks = typeof limit === 'number' && Number.isFinite(limit) ? tasks.slice(0, limit) : tasks;
|
|
|
|
fs.mkdirSync(path.dirname(absOut), { recursive: true });
|
|
|
|
// Use JSON format (pretty) for .json files, JSONL for .jsonl files
|
|
if (absOut.endsWith('.json')) {
|
|
fs.writeFileSync(absOut, JSON.stringify(finalTasks, null, 2), 'utf8');
|
|
} else {
|
|
// JSONL format: one JSON object per line
|
|
const lines = finalTasks.map(t => JSON.stringify(t));
|
|
fs.writeFileSync(absOut, lines.join('\n') + (lines.length ? '\n' : ''), 'utf8');
|
|
}
|
|
|
|
const reachable = finalTasks.filter(t => t.trajectoryCount > 0).length;
|
|
const unreachable = finalTasks.length - reachable;
|
|
const totalTrajectoriesByTask = finalTasks.reduce((sum, t) => sum + (t.trajectoryCount ?? 0), 0);
|
|
console.log(`[ActionTasks] graph=${path.relative(process.cwd(), absGraph)}`);
|
|
console.log(`[ActionTasks] startNodes=${startNodeIds.join(', ')}`);
|
|
console.log(`[ActionTasks] tasks=${finalTasks.length} reachable=${reachable} unreachable=${unreachable}`);
|
|
console.log(`[ActionTasks] uniqueActionNodes=${uniqueActionNodes}`);
|
|
console.log(`[ActionTasks] totalTrajectoriesByTargetNode=${totalTrajectoriesByTargetNode} (sum of trajectories per target node with actions)`);
|
|
console.log(`[ActionTasks] totalTrajectoriesByTask=${totalTrajectoriesByTask} (sum of trajectoryCount across tasks)`);
|
|
console.log(`[ActionTasks] wrote ${path.relative(process.cwd(), absOut)}`);
|
|
}
|
|
|
|
main();
|
|
|