@llm4ts/shell 2.37.0 → 2.39.0

package/flows/modernize-extract.js

@@ -39,10 +39,11 @@ import { loadPatternCards, matchingPatternCards } from "@llm4ts/flow/Patterns";
 import { legacySourceWorkspaceLimits, workspaceLimitsFromEnv } from "@llm4ts/flow/Workspace";
 import { ReviewIssue } from "@llm4ts/flow/Review";
 import { coverageReport, coverageUnits, features, matchingFiles, specSchemaIssues } from "@llm4ts/flow/SpecChecks";
-import { SurveyGraph, closureFor, surveyGraph } from "@llm4ts/flow/Survey";
+import { SurveyGraph, closureFor } from "@llm4ts/flow/Survey";
+import { freshGraph, graphCachePath } from "@llm4ts/flow/GraphCache";
 import { withDraftApproval, requireApproval } from "@llm4ts/flow/Approval";
 import { ProgramArtifacts, ProgramUnit, extractProgramsResumably, programArtifactPaths } from "@llm4ts/flow/Artifacts";
-import { ModDir, analystSystem, analystTurns, fixTurn, globalFixAsk, judgeIssueProgram, makeProgramJudge, maxClosureFiles, positiveEnvInt, programArtifactsJsonSchema, programAsk, programFixAsk, programName, readmeFor, wavePrograms } from "./lib/modernize-extract.js";
+import { ModDir, analystSystem, analystTurns, fixTurn, globalFixAsk, judgeIssueProgram, makeProgramJudge, maxClosureFiles, positiveEnvInt, programArtifactsJsonSchema, programAsk, programFixAsk, programName, readmeFor, wavePrograms, closureSection } from "./lib/modernize-extract.js";
 const MaxRounds = 3;
 /**
  * Programs extracted (and judged) at once. The programs of a wave are
@@ -109,16 +110,19 @@ const program = Effect.gen(function* () {
             ...(yield* loadKitPatternCards(opened))
         ];
         // The dependency graph the analysts' include closures are resolved
-        // from — walked over the pack's `## Survey:` edge regexes.
-        const graph = yield* stage(context.events, "graph", pack.survey.length === 0
+        // from: the cached code graph (ADR 0030), rebuilt from the pack's rules
+        // when a file changed, with the survey's LLM edges carried along.
+        const graph = yield* stage(context.events, "graph", pack.graph.edges.length === 0 && pack.graph.joins.length === 0
             ? context.events
                 .publish(Info.make({
-                message: "pack has no '## Survey:' edge regexes — the analyst gets no resolved closure"
+                message: "pack has no graph rules — the analyst gets no resolved closure"
             }))
                 .pipe(Effect.as(SurveyGraph.make({ nodes: [], edges: [] })))
-            : surveyGraph(repo, pack.sources ?? ".*", pack.coverage, pack.survey, {
-                ...(pack.exclude === undefined ? {} : { exclude: pack.exclude })
-            }));
+            : freshGraph(files, graphCachePath(input.workDir, pack.name), pack, repo).pipe(Effect.tap((fresh) => context.events.publish(Info.make({
+                message: fresh.reused
+                    ? "graph cache reused"
+                    : "graph rebuilt (scanner layer); LLM edges carried where their evidence is unchanged"
+            }))), Effect.map((fresh) => fresh.graph)));
         // One structured analyst call per program, resumable per program: a rerun
         // skips every program whose spec exists, and each program gets its own
         // commit scoped to its four files. LLM4TS_EXTRACT_CONCURRENCY runs that
@@ -138,6 +142,11 @@ const program = Effect.gen(function* () {
                     message: `extracting ${target.sourcePath} (${ordinal}/${units.length})`
                 }));
                 return yield* structuredAndPublish(context.coder, context.events, `${system}\n\n${programAsk(pack, target.sourcePath, closureFor(graph, target.name, maxClosureFiles()))}`, ProgramArtifacts, programArtifactsJsonSchema, "coder").pipe(
+                // The spec opens with the program's closure diagram (ADR 0030).
+                Effect.map((artifacts) => ProgramArtifacts.make({
+                    ...artifacts,
+                    spec: `${closureSection(graph, target.name)}\n\n${artifacts.spec}`
+                })), 
                 // A turn-limit trip is the wedged-agent tail, not a
                 // failure: keep whatever the analyst already produced.
                 Effect.catchIf((error) => error.cause?._tag === "TurnLimitError", (error) => Effect.gen(function* () {

package/flows/modernize-pack-check.js

@@ -10,19 +10,23 @@
 //   2. estate — the files `sources:` selects (minus `exclude:`), the files
 //      `programs:` selects, and for every `## Coverage:` and `## Survey:` rule
 //      the units it captures, with a sample of each so a regex typo is
-//      visible at a glance.
+//      visible at a glance; then the code graph (ADR 0030): what every
+//      `## Node:`, `## Edge:` and `## Join:` rule produced, the unresolved
+//      items by reason, and one verdict line per `## Probe:`.
 //   3. verdict — hard failures (the pack does not load, `sources:` or
-//      `programs:` match nothing) abort with exit code 1; likely mistakes (a
-//      rule capturing no unit, a missing phase prompt, a scaffold path that
-//      does not exist, no reviewer lens, no judge dimension) are listed as
-//      warnings and the flow exits 0.
+//      `programs:` match nothing, a probe is broken or names an unknown node)
+//      abort with exit code 1; likely mistakes (a rule capturing no unit, a
+//      missing phase prompt, a scaffold path that does not exist, no reviewer
+//      lens, no judge dimension) are listed as warnings and the flow exits 0.
 //
 // Run: LLM4TS_PACK=packs/my-pack modernize-pack-check --repo ~/estates/legacy
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import * as Effect from "effect/Effect";
 import { FlowAborted, Info, makeNodeWorkspace, mock, openPack, resolveFlowInput, runFlowMain, runNode, stage } from "@llm4ts/runner";
+import { graphStats, probeResults } from "@llm4ts/flow/GraphQuery";
 import { coverageUnits, matchingFiles } from "@llm4ts/flow/SpecChecks";
+import { buildCodeGraph, nodeId, nodeKind } from "@llm4ts/flow/Survey";
 import { legacySourceWorkspaceLimits, workspaceLimitsFromEnv } from "@llm4ts/flow/Workspace";
 /** Prompt sidecars the modernization phases read, with the phase that reads each. */
 const phasePrompts = [
@@ -42,6 +46,8 @@ const sample = (units) => units.length === 0
     : units.slice(0, sampleSize).join(", ") +
         (units.length > sampleSize ? ` … +${units.length - sampleSize} more` : "");
 const plural = (count, noun, many = `${noun}s`) => `${count} ${count === 1 ? noun : many}`;
+const probeFrom = (path) => path[0]?.from ?? "";
+const probeTo = (path) => path.at(-1)?.to ?? "";
 const program = Effect.gen(function* () {
     const input = yield* resolveFlowInput("Check the pack against the estate");
     yield* runNode({
@@ -147,6 +153,60 @@ const program = Effect.gen(function* () {
             });
             yield* report("coverage", pack.coverage);
             yield* report("survey", pack.survey);
+            // The code graph (ADR 0030): rule by rule, then the holes, then the probes.
+            const build = yield* buildCodeGraph(repo, {
+                sources: sourcesRegex,
+                ...(pack.exclude === undefined ? {} : { exclude: pack.exclude }),
+                coverage: pack.coverage,
+                rules: pack.graph
+            });
+            const stats = graphStats(build.graph);
+            for (const rule of pack.graph.nodes) {
+                const count = stats.nodes[rule.kind] ?? 0;
+                const samples = build.graph.nodes
+                    .filter((node) => nodeKind(node) === rule.kind)
+                    .map((node) => node.name);
+                yield* say(`node '${rule.kind}': ${plural(count, "node")} — ${sample(samples)}`);
+                if (count === 0) {
+                    warnings.push(`node rule '${rule.kind}' matched nothing: files '${rule.files}', pattern '${rule.pattern}'`);
+                }
+            }
+            const duplicates = build.graph.nodes.filter((node) => nodeId(node).includes("~"));
+            if (duplicates.length > 0) {
+                warnings.push(`${plural(duplicates.length, "node")} share a name within one file (ids with '~n'): ${sample(duplicates.map(nodeId))}`);
+            }
+            for (const rule of pack.graph.edges.filter((rule) => rule.fromKind !== "file" || rule.toKind !== "file")) {
+                const count = stats.edges[rule.kind] ?? 0;
+                yield* say(`edge '${rule.kind}': ${plural(count, "edge")}`);
+                if (count === 0) {
+                    warnings.push(`edge rule '${rule.kind}' produced no edge`);
+                }
+            }
+            for (const rule of pack.graph.joins) {
+                const count = build.graph.edges.filter((edge) => edge.kind === rule.kind && (edge.mechanism ?? "").startsWith("join:")).length;
+                yield* say(`join '${rule.kind}' (${rule.fromKind}.${rule.fromAttr} → ${rule.toKind}.${rule.toAttr}, ${rule.match}, scope ${rule.scope}): ${plural(count, "edge")}`);
+                if (count === 0) {
+                    warnings.push(`join '${rule.kind}' produced no edge`);
+                }
+            }
+            const byReason = Object.entries(stats.unresolved)
+                .map(([reason, count]) => `${reason} ${count}`)
+                .join(", ");
+            yield* say(`unresolved: ${build.graph.unresolved.length === 0 ? "none" : byReason}`);
+            for (const item of build.graph.unresolved.slice(0, 20)) {
+                yield* say(`  ${item.reason} [${item.rule}] ${item.node}${item.reference === undefined ? "" : ` → ${item.reference}`} (${item.file}:${item.line})`);
+            }
+            for (const result of probeResults(build.graph, pack.graph.probes)) {
+                const via = result.path === undefined
+                    ? ""
+                    : result.path.length === 0
+                        ? " (same node)"
+                        : ` (${probeFrom(result.path)} → ${probeTo(result.path)} via ${result.path.map((edge) => edge.kind).join(" → ")})`;
+                yield* say(`probe '${result.probe.name}': ${result.status}${via}`);
+                if (result.status !== "ok") {
+                    failures.push(`probe '${result.probe.name}' is ${result.status} (${result.probe.from} → ${result.probe.to})`);
+                }
+            }
         }));
         yield* stage(context.events, "verdict", Effect.gen(function* () {
             for (const warning of warnings) {

package/flows/modernize-refine.js

@@ -37,7 +37,8 @@ import { structuredAndPublish } from "@llm4ts/flow/Flow";
 import { FlowEvents } from "@llm4ts/flow/FlowEvents";
 import { Task } from "@llm4ts/flow/Plan";
 import { coverageUnits, matchingFiles } from "@llm4ts/flow/SpecChecks";
-import { SurveyGraph, closureFor, surveyGraph } from "@llm4ts/flow/Survey";
+import { SurveyGraph, closureFor } from "@llm4ts/flow/Survey";
+import { freshGraph, graphCachePath } from "@llm4ts/flow/GraphCache";
 import { withDraftApproval } from "@llm4ts/flow/Approval";
 import { legacySourceWorkspaceLimits, workspaceLimitsFromEnv } from "@llm4ts/flow/Workspace";
 import { FlowAborted, Info, Plan, asReadOnly, coderFromEnv, defaultPlanInstructions, makeNodeWorkspace, nodePlainFileStore, openPack, planFrom, resolveFlowInput, runFlowMain, runNode, stage, withTurnLimit } from "@llm4ts/runner";
@@ -112,11 +113,9 @@ const program = Effect.gen(function* () {
         const writeDecisions = Effect.gen(function* () {
             yield* files.writeAtomic(decisionsPath, renderDecisions(decisions));
         });
-        const graph = yield* stage(context.events, "graph", pack.survey.length === 0
+        const graph = yield* stage(context.events, "graph", pack.graph.edges.length === 0 && pack.graph.joins.length === 0
             ? Effect.succeed(SurveyGraph.make({ nodes: [], edges: [] }))
-            : surveyGraph(repo, pack.sources ?? ".*", pack.coverage, pack.survey, {
-                ...(pack.exclude === undefined ? {} : { exclude: pack.exclude })
-            }));
+            : freshGraph(files, graphCachePath(input.workDir, pack.name), pack, repo).pipe(Effect.map((fresh) => fresh.graph)));
         const system = analystSystem(pack);
         const limit = budget();
         const judgeProgram = makeProgramJudge({

package/flows/modernize-survey.js

@@ -1,11 +1,13 @@
 // Legacy modernization phase 0: inventory the estate, refine its dependency graph, triage, and propose a human-approved wave plan.
 //
 // Runs rooted at the LEGACY repository (`--repo <legacy>`). Deterministic first:
-// the graph comes from the pack's `sources:` regex and `## Survey:` edge rules
-// (no LLM), then a read-only reasoning pass proposes the edges the regexes
-// missed (each with source evidence; `mergeSurveyEdges` validates and tags them
-// `llm-…`), and finally triage classifies every unit rewrite | retire | wrap
-// and slices the rewrites into dependency-coherent waves. The wave plan lands
+// the graph comes from the pack's `sources:` regex and its `## Survey:` /
+// `## Node:` / `## Edge:` / `## Join:` rules (no LLM; ADR 0030), cached under
+// `.llm4ts/graph/<pack>.json` by file hash. What the scanner could not resolve
+// becomes a bounded worklist for a read-only reasoning pass (attr fills and
+// edges between EXISTING nodes, each verified against the cited source line),
+// and finally triage classifies every unit rewrite | retire | wrap and slices
+// the rewrites into dependency-coherent waves. The wave plan lands
 // at docs/modernization/wave-plan.md with an UNCHECKED approval marker — a
 // human reviews, flips `- [x] Approved`, and only then does modernize-extract
 // start (LLM4TS_WAVE=<name> scopes extraction to one wave).
@@ -27,9 +29,13 @@ import { FlowAborted, Info, asReadOnly, coderFromEnv, makeNodeWorkspace, nodePla
 import { FlowEvents } from "@llm4ts/flow/FlowEvents";
 import { structuredAndPublish } from "@llm4ts/flow/Flow";
 import { loadBenchRecords, renderBenchReport } from "@llm4ts/flow/BenchReport";
-import { SurveyEdge, mergeSurveyEdges, renderSurveyGraphJson, renderSurveyInventory, surveyGraph, surveyRefinePrompt, surveyTriagePrompt } from "@llm4ts/flow/Survey";
+import { nodeKind, renderSurveyGraphJson, renderSurveyInventory, surveyTriagePrompt } from "@llm4ts/flow/Survey";
 import { discoveryOverflowAdvice, legacySourceWorkspaceLimits, workspaceLimitsFromEnv } from "@llm4ts/flow/Workspace";
 import { withDraftApproval } from "@llm4ts/flow/Approval";
+import { freshGraph, graphCachePath, updateGraphCache } from "@llm4ts/flow/GraphCache";
+import { WorklistAnswer, mergeWorklist, renderWorklistReport, verifyWorklistAnswer, worklistAnswerJsonSchema, worklistBatches, worklistOf, worklistPrompt } from "@llm4ts/flow/GraphWorklist";
+import { wholeView } from "@llm4ts/flow/GraphQuery";
+import { renderClusterDiagrams, renderEntryPaths, renderGraphDot } from "@llm4ts/flow/GraphRender";
 const ModDir = "docs/modernization";
 class NodeTriage extends Schema.Class("NodeTriage")({
     name: Schema.String,
@@ -80,63 +86,21 @@ const surveyOutcomeJsonSchema = {
     },
     required: ["triage", "waves", "notes"]
 };
-class RefinedEdge extends Schema.Class("RefinedEdge")({
-    from: Schema.String,
-    to: Schema.String,
-    kind: Schema.String,
-    evidence: Schema.String
-}) {
-}
-class GraphRefinement extends Schema.Class("GraphRefinement")({
-    edges: Schema.Array(RefinedEdge),
-    notes: Schema.Array(Schema.String)
-}) {
-}
-const graphRefinementJsonSchema = {
-    type: "object",
-    properties: {
-        edges: {
-            type: "array",
-            items: {
-                type: "object",
-                properties: {
-                    from: { type: "string" },
-                    to: { type: "string" },
-                    kind: { type: "string" },
-                    evidence: { type: "string" }
-                },
-                required: ["from", "to", "kind", "evidence"]
-            }
-        },
-        notes: { type: "array", items: { type: "string" } }
-    },
-    required: ["edges", "notes"]
-};
 const tableCell = (text) => text.split(/\r?\n/).join(" ").replaceAll("|", "\\|");
-const renderRefine = (refinement, kept) => {
-    const keptKeys = new Set(kept.map((edge) => `${edge.from}${edge.to}`));
-    const rows = refinement.edges.map((edge) => {
-        const status = keptKeys.has(`${edge.from}${edge.to}`)
-            ? "added"
-            : "dropped — duplicate, self-loop, or unknown unit";
-        return `| ${edge.from} | ${edge.to} | ${edge.kind} | ${status} | ${tableCell(edge.evidence)} |`;
-    });
-    const notes = refinement.notes.length === 0
-        ? []
-        : ["## Unresolved", "", ...refinement.notes.map((note) => `- ${tableCell(note)}`)];
-    return ([
-        "# Graph refine (LLM)",
-        "",
-        `${kept.length} of ${refinement.edges.length} proposed edge(s) merged into \`graph.json\` (kind prefixed \`llm-\`).`,
-        "Each carries the source statement that establishes it — verify before trusting a wave built on it.",
-        "",
-        "| From | To | Kind | Status | Evidence |",
-        "| ---- | -- | ---- | ------ | -------- |",
-        ...rows,
-        "",
-        ...notes
-    ].join("\n") + "\n");
-};
+/** inventory.md (units, cluster diagrams, entry paths), graph.json and graph.dot. */
+const writeGraphArtifacts = (repo, pack, graph) => Effect.gen(function* () {
+    const programs = graph.nodes
+        .filter((node) => nodeKind(node) === "file")
+        .map((node) => node.name);
+    const inventory = [
+        renderSurveyInventory(graph),
+        renderClusterDiagrams(graph, pack.consolidate ?? { cluster: [], context: [] }, programs),
+        renderEntryPaths(graph)
+    ].join("\n");
+    yield* repo.write(join(ModDir, "inventory.md"), inventory);
+    yield* repo.write(join(ModDir, "graph.json"), renderSurveyGraphJson(graph));
+    yield* repo.write(join(ModDir, "graph.dot"), renderGraphDot(wholeView(graph), graph));
+});
 const renderWavePlan = (outcome, graph, projection) => {
     const triageRows = [...outcome.triage]
         .sort((left, right) => left.name.localeCompare(right.name))
@@ -182,16 +146,15 @@ const program = Effect.gen(function* () {
             launchDir: input.workspace,
             flowDir: import.meta.dirname
         }));
-        if (pack.survey.length === 0) {
+        if (pack.graph.edges.length === 0 && pack.graph.joins.length === 0) {
             return yield* FlowAborted.make({
-                message: `pack '${pack.name}' has no '## Survey:' sections — add the dependency-edge ` +
-                    "regexes (CALL/COPY/EXEC PGM…) the graph should be built from"
+                message: `pack '${pack.name}' has no '## Survey:', '## Edge:' or '## Join:' sections — add the ` +
+                    "dependency-edge rules (CALL/COPY/EXEC PGM, ajax → servlet…) the graph should be built from"
             });
         }
-        const graph = yield* stage(context.events, "graph", Effect.gen(function* () {
-            const built = yield* surveyGraph(repo, pack.sources ?? ".*", pack.coverage, pack.survey, {
-                ...(pack.exclude === undefined ? {} : { exclude: pack.exclude })
-            }).pipe(
+        const cachePath = graphCachePath(input.workDir, pack.name);
+        const fresh = yield* stage(context.events, "graph", Effect.gen(function* () {
+            const built = yield* freshGraph(nodePlainFileStore, cachePath, pack, repo).pipe(
             // The cap is a guard against runaway trees, not a verdict on the
             // estate: name the three knobs instead of a bare limit number.
             Effect.catchTag("WorkspaceLimit", (error) => Effect.fail(error.operation === "discovery results"
@@ -199,33 +162,63 @@ const program = Effect.gen(function* () {
                     message: `${input.workDir}: ${discoveryOverflowAdvice(limits)}`
                 })
                 : error)));
-            yield* repo.write(join(ModDir, "inventory.md"), renderSurveyInventory(built));
-            yield* repo.write(join(ModDir, "graph.json"), renderSurveyGraphJson(built));
-            yield* context.events.publish(Info.make({ message: `${built.nodes.length} unit(s), ${built.edges.length} edge(s)` }));
+            yield* writeGraphArtifacts(repo, pack, built.graph);
+            yield* context.events.publish(Info.make({
+                message: `${built.graph.nodes.length} node(s), ${built.graph.edges.length} edge(s), ` +
+                    `${built.graph.unresolved.length} unresolved` +
+                    (built.reused ? " (graph cache reused)" : "")
+            }));
             return built;
         }));
+        const graph = fresh.graph;
         const refined = yield* stage(context.events, "graph refine", refineDisabled(process.env)
             ? context.events
                 .publish(Info.make({ message: "LLM4TS_GRAPH_REFINE=off — regex graph ships unrefined" }))
                 .pipe(Effect.as(graph))
             : Effect.gen(function* () {
-                const refinement = yield* withShrink("survey refine", (cap) => Effect.gen(function* () {
-                    const prompt = yield* capped("graph", surveyRefinePrompt(graph, {
-                        rules: pack.survey,
-                        guidance: pack.prompt("survey-refine")
-                    }), cap);
-                    return yield* structuredAndPublish(context.reasoning, context.events, prompt, GraphRefinement, graphRefinementJsonSchema);
-                })).pipe(Effect.provideService(FlowEvents, context.events));
-                const merged = mergeSurveyEdges(graph, refinement.edges.map((edge) => SurveyEdge.make({ from: edge.from, to: edge.to, kind: edge.kind })));
-                const kept = merged.edges.filter((edge) => edge.kind.startsWith("llm-"));
-                yield* repo.write(join(ModDir, "graph-refine.md"), renderRefine(refinement, kept));
-                if (kept.length > 0) {
-                    yield* repo.write(join(ModDir, "inventory.md"), renderSurveyInventory(merged));
-                    yield* repo.write(join(ModDir, "graph.json"), renderSurveyGraphJson(merged));
+                const contents = new Map();
+                const load = (path) => contents.has(path)
+                    ? Effect.void
+                    : repo.read(path).pipe(Effect.orElseSucceed(() => ""), Effect.map((text) => void contents.set(path, text)));
+                const read = (path) => contents.get(path);
+                for (const file of new Set(graph.unresolved.map((item) => item.file))) {
+                    yield* load(file);
+                }
+                const items = worklistOf(graph, read, pack.graph.worklistMax, pack.graph);
+                if (items.length === 0) {
+                    yield* context.events.publish(Info.make({ message: "nothing unresolved — no LLM pass needed" }));
+                    return graph;
+                }
+                let merged = graph;
+                const accepted = [];
+                const notes = [];
+                for (const batch of worklistBatches(items, pack.graph.batchSize)) {
+                    const answer = yield* withShrink("graph worklist", (cap) => Effect.gen(function* () {
+                        const prompt = yield* capped("worklist", worklistPrompt(batch, pack.prompt("survey-refine")), cap);
+                        return yield* structuredAndPublish(context.reasoning, context.events, prompt, WorklistAnswer, worklistAnswerJsonSchema);
+                    })).pipe(Effect.provideService(FlowEvents, context.events));
+                    for (const file of new Set([
+                        ...answer.edges.map((edge) => edge.evidence.file),
+                        ...answer.attrs.map((attr) => attr.evidence.file)
+                    ])) {
+                        yield* load(file);
+                    }
+                    const verified = verifyWorklistAnswer(answer, merged, read);
+                    merged = mergeWorklist(merged, verified, pack.graph);
+                    accepted.push(verified);
+                    notes.push(...answer.notes);
                 }
+                const all = {
+                    edges: accepted.flatMap((verified) => verified.edges),
+                    fills: accepted.flatMap((verified) => verified.fills),
+                    dropped: accepted.flatMap((verified) => verified.dropped)
+                };
+                yield* repo.write(join(ModDir, "graph-refine.md"), renderWorklistReport(items, all, notes));
+                yield* updateGraphCache(nodePlainFileStore, cachePath, fresh.cache, merged);
+                yield* writeGraphArtifacts(repo, pack, merged);
                 yield* context.events.publish(Info.make({
-                    message: `${kept.length} regex-missed edge(s) merged ` +
-                        `(${refinement.edges.length} proposed by the LLM)`
+                    message: `${all.edges.length} edge(s) and ${all.fills.length} fill(s) accepted from ` +
+                        `${items.length} unresolved item(s); ${all.dropped.length} dropped`
                 }));
                 return merged;
             }));

package/kits/j2ee-nextjs/flows/lib/convert.js

@@ -19,7 +19,8 @@ import { openApiFor, openApiForFeature, parsePageSpec, renderPageSpec } from "@l
 import { loadPatternCards, matchingPatternCards } from "@llm4ts/flow/Patterns";
 import { Task } from "@llm4ts/flow/Plan";
 import { judgeAllPrograms } from "@llm4ts/flow/ProgramJudge";
-import { closureFor, surveyGraph } from "@llm4ts/flow/Survey";
+import { closureFor } from "@llm4ts/flow/Survey";
+import { freshGraph, graphCachePath } from "@llm4ts/flow/GraphCache";
 import { estimatedUsageOptionsFromEnv, makeEstimatedUsageMeter } from "@llm4ts/flow/EstimatedUsage";
 import { legacySourceWorkspaceLimits, workspaceLimitsFromEnv } from "@llm4ts/flow/Workspace";
 export const positiveEnvInt = (environment, name, fallback) => {
@@ -213,7 +214,7 @@ const legacyEvidence = Effect.fn("convert.legacyEvidence")(function* (deps, page
     const source = sourcePath === undefined
         ? ""
         : yield* deps.legacy.read(sourcePath).pipe(Effect.orElseSucceed(() => ""));
-    const graph = yield* surveyGraph(deps.legacy, deps.pack.sources ?? ".*", deps.pack.coverage, deps.pack.survey);
+    const graph = (yield* freshGraph(deps.files, graphCachePath(deps.legacyDir, deps.pack.name), deps.pack, deps.legacy)).graph;
     const closure = closureFor(graph, page, positiveEnvInt(deps.environment, "LLM4TS_MAX_CLOSURE_FILES", 12));
     const parts = [];
     if (sourcePath !== undefined) {
@@ -480,7 +481,7 @@ export const convertFeature = Effect.fn("convert.feature")(function* (deps, feat
     for (const page of pages) {
         specs.set(page, yield* readSpec(deps, page));
     }
-    const graph = yield* surveyGraph(deps.legacy, deps.pack.sources ?? ".*", deps.pack.coverage, deps.pack.survey);
+    const graph = (yield* freshGraph(deps.files, graphCachePath(deps.legacyDir, deps.pack.name), deps.pack, deps.legacy)).graph;
     const order = navigationOrder({ ...feature, programs: pages }, graph, deps.pack.consolidate ?? { cluster: [], context: [] });
     const contractPath = `contracts/${feature.id}.openapi.yaml`;
     const contract = yield* openApiForFeature(feature, order.map((page) => specs.get(page)?.spec).filter((spec) => spec !== undefined));

package/kits/j2ee-nextjs/packs/j2ee-nextjs-spa/pack.md

@@ -49,15 +49,48 @@ unit: <jsp:include page="([^"]+)"
 files: .*web\.xml
 unit: <servlet-class>[a-z.]*\.([A-Za-z0-9]+)</servlet-class>
 
-## Survey: jsp-form-action
+## Node: ajax-call
 
-files: .*\.jsp
-unit: action="([^"]+)"
+files: .*\.(jsp|js)
+pattern: (?:["']?url["']?\s*:\s*|\$\.(?:get|post|getJSON)\(\s*)['"](?<name>[^'"]+)['"]
+attrs: url=name
 
-## Survey: jsp-ajax-target
+## Node: form
 
 files: .*\.jsp
-unit: url:\s*['"]([^'"?]+)
+pattern: <(?:[a-z]+:)?[Ff][Oo][Rr][Mm]\b[^>]*\b[Aa][Cc][Tt][Ii][Oo][Nn]=["'](?<name>[^"']+)["']
+attrs: url=name
+
+## Node: servlet-mapping
+
+files: .*web\.xml
+pattern: <servlet-mapping>\s*<servlet-name>(?<name>[^<]+)</servlet-name>\s*<url-pattern>(?<url>[^<]+)</url-pattern>
+descriptor: yes
+
+## Node: servlet-decl
+
+files: .*web\.xml
+pattern: <servlet>(?:(?!</servlet>)[\s\S])*?<servlet-name>(?<name>[^<]+)</servlet-name>(?:(?!</servlet>)[\s\S])*?<servlet-class>(?:[a-z0-9_]+\.)*(?<class>[A-Za-z0-9_]+)</servlet-class>
+descriptor: yes
+anchor: class
+
+## Join: jsp-ajax-target
+
+from: ajax-call.url
+to: servlet-mapping.url
+match: url
+
+## Join: jsp-form-action
+
+from: form.url
+to: servlet-mapping.url
+match: url
+
+## Join: servlet-wiring
+
+from: servlet-mapping.name
+to: servlet-decl.name
+scope: file
 
 ## Consolidate
 

package/kits/mainframe-java/packs/cobol-kafka/pack.md

@@ -49,3 +49,27 @@ unit: ^ {6}[ ]*COPY +([A-Z0-9]+)
 
 files: .*\.(jcl|JCL)
 unit: EXEC +PGM=([A-Z0-9]+)
+
+## Node: cobol-section
+
+files: .*\.(cbl|CBL)
+pattern: ^ {7}(?<name>[A-Z0-9][A-Z0-9-]*) +SECTION\.
+
+## Node: cobol-paragraph
+
+files: .*\.(cbl|CBL)
+pattern: ^ {7}(?<name>\d{4}-[A-Z0-9-]+)\.
+
+## Edge: performs
+
+files: .*\.(cbl|CBL)
+pattern: PERFORM +(?<to>\d{4}-[A-Z0-9-]+)(?: +THRU +(?<thru>\d{4}-[A-Z0-9-]+))?
+from: cobol-paragraph
+to: cobol-paragraph
+
+## Edge: goes-to
+
+files: .*\.(cbl|CBL)
+pattern: GO +TO +(?<to>\d{4}-[A-Z0-9-]+)
+from: cobol-paragraph
+to: cobol-paragraph

package/kits/mainframe-java/packs/cobol-springboot/pack.md

@@ -50,6 +50,30 @@ unit: ^ {6}[ ]*COPY +([A-Z0-9]+)
 files: .*\.(jcl|JCL)
 unit: EXEC +PGM=([A-Z0-9]+)
 
+## Node: cobol-section
+
+files: .*\.(cbl|CBL)
+pattern: ^ {7}(?<name>[A-Z0-9][A-Z0-9-]*) +SECTION\.
+
+## Node: cobol-paragraph
+
+files: .*\.(cbl|CBL)
+pattern: ^ {7}(?<name>\d{4}-[A-Z0-9-]+)\.
+
+## Edge: performs
+
+files: .*\.(cbl|CBL)
+pattern: PERFORM +(?<to>\d{4}-[A-Z0-9-]+)(?: +THRU +(?<thru>\d{4}-[A-Z0-9-]+))?
+from: cobol-paragraph
+to: cobol-paragraph
+
+## Edge: goes-to
+
+files: .*\.(cbl|CBL)
+pattern: GO +TO +(?<to>\d{4}-[A-Z0-9-]+)
+from: cobol-paragraph
+to: cobol-paragraph
+
 ## Consolidate
 
 - cluster: calls, exec-pgm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llm4ts/shell",
-  "version": "2.37.0",
+  "version": "2.39.0",
   "description": "Interactive shell and CLI for llm4ts: flow discovery, run-a-flow, and view",
   "license": "MIT",
   "type": "module",
@@ -52,9 +52,9 @@
   "dependencies": {
     "@effect/platform-node": "4.0.0",
     "@effect/platform-node-shared": "4.0.0",
-    "@llm4ts/core": "2.37.0",
-    "@llm4ts/flow": "2.37.0",
-    "@llm4ts/runner": "2.37.0"
+    "@llm4ts/core": "2.39.0",
+    "@llm4ts/flow": "2.39.0",
+    "@llm4ts/runner": "2.39.0"
   },
   "peerDependencies": {
     "effect": "4.0.0"