@thoughtflow/core 0.1.2

package/dist/tools/planning/solve-complex.tool.js

@@ -0,0 +1,633 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolveComplexTool = void 0;
+const zod_1 = require("zod");
+const tool_base_class_1 = require("../base/tool-base.class");
+const problem_tree_class_1 = require("../../libs/problem-tree.class");
+const DEFAULT_CROSS_CUTTING = [
+    "auth, authentication, authorization, access control, permissions, roles",
+    "routing, navigation, URLs, paths, redirects",
+    "state management, data flow, context, store",
+    "UI/frontend components, rendering, styles, layout",
+    "translations, i18n, localization, RTL",
+    "testing, unit tests, integration tests, e2e",
+    "documentation, README, API docs, changelog",
+    "accessibility, a11y, ARIA, keyboard navigation",
+    "SEO, meta tags, sitemap, analytics",
+    "performance, bundle size, lazy loading, caching",
+    "error handling, error boundaries, logging, monitoring",
+    "backward compatibility, migrations, deprecation",
+];
+const DEFAULT_HEURISTIC_RULES = [
+    {
+        keywords: ["nav", "rout", "link", "navigat", "menu", "sidebar", "header", "footer", "breadcrumb"],
+        issues: [
+            { type: "dependency", title: "Routing system", desc: "Navigation changes affect the routing configuration" },
+            { type: "dependency", title: "Breadcrumbs component", desc: "Breadcrumbs may reference the same navigation structure" },
+            { type: "dependency", title: "Mobile navigation", desc: "Mobile menu may have separate navigation logic" },
+            { type: "risk", title: "Auth guards", desc: "New navigation items may need auth guard checks" },
+        ],
+    },
+    {
+        keywords: ["form", "input", "valid", "submit", "field"],
+        issues: [
+            { type: "dependency", title: "Validation schema", desc: "Form changes may affect validation schema" },
+            { type: "dependency", title: "API contract", desc: "Form submissions may change API payload" },
+            { type: "risk", title: "Error handling", desc: "New validation may need error UI updates" },
+        ],
+    },
+    {
+        keywords: ["api", "endpoint", "request", "response", "rest", "graphql", "mutation", "query", "resolver"],
+        issues: [
+            { type: "dependency", title: "Type definitions", desc: "API changes affect shared types/interfaces" },
+            { type: "dependency", title: "Error handling", desc: "New endpoints need error handling" },
+            { type: "risk", title: "Backward compatibility", desc: "API changes may break existing consumers" },
+        ],
+    },
+    {
+        keywords: ["auth", "login", "permission", "role", "token", "session", "jwt", "oauth"],
+        issues: [
+            { type: "dependency", title: "Authentication flow", desc: "Auth changes affect login/logout/refresh flow" },
+            { type: "dependency", title: "Authorization checks", desc: "Permission checks may exist in multiple places" },
+            { type: "risk", title: "Session management", desc: "Token expiry, refresh, and session state consistency" },
+        ],
+    },
+    {
+        keywords: ["db", "database", "schema", "migration", "model", "entity", "table", "column"],
+        issues: [
+            { type: "dependency", title: "Database schema", desc: "Schema changes require migration scripts" },
+            { type: "dependency", title: "ORM/query layer", desc: "Data access layer may need updates" },
+            { type: "risk", title: "Data migration", desc: "Existing data may need transformation" },
+        ],
+    },
+    {
+        keywords: ["docker", "deploy", "ci", "cd", "pipeline", "build", "kubernetes", "k8s", "helm"],
+        issues: [
+            { type: "dependency", title: "CI/CD pipeline", desc: "Build and deployment configuration needs update" },
+            { type: "dependency", title: "Docker configuration", desc: "Dockerfile or compose may need changes" },
+            { type: "risk", title: "Environment parity", desc: "Dev/staging/prod environment differences" },
+        ],
+    },
+    {
+        keywords: ["test", "spec", "coverage", "jest", "pytest", "rspec", "e2e", "integration"],
+        issues: [
+            { type: "dependency", title: "Unit tests", desc: "Existing tests may break or need updating" },
+            { type: "dependency", title: "Integration tests", desc: "Cross-component test scenarios need updating" },
+            { type: "risk", title: "Coverage regression", desc: "New code may not meet coverage thresholds" },
+        ],
+    },
+    {
+        keywords: ["perf", "performance", "optimize", "slow", "bundle", "latency", "cache", "load"],
+        issues: [
+            { type: "dependency", title: "Bundle size", desc: "Changes may increase bundle/package size" },
+            { type: "dependency", title: "Database queries", desc: "New queries may need indexing optimization" },
+            { type: "risk", title: "Memory usage", desc: "Increased memory footprint under load" },
+        ],
+    },
+];
+const SubProblemSchema = zod_1.z.object({
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    type: zod_1.z.enum(["problem", "dependency", "solution", "bug", "risk", "insight"]),
+    confidence: zod_1.z.number().min(0).max(1),
+    dependencies: zod_1.z.array(zod_1.z.string()).optional(),
+    predictedIssues: zod_1.z.array(zod_1.z.string()).optional(),
+    searchTerms: zod_1.z.array(zod_1.z.string()).optional(),
+});
+const DecompositionSchema = zod_1.z.object({
+    subProblems: zod_1.z.array(SubProblemSchema).min(1).max(30),
+    crossDependencies: zod_1.z.array(zod_1.z.object({
+        from: zod_1.z.string(),
+        to: zod_1.z.string(),
+        type: zod_1.z.enum(["depends_on", "causes", "blocks", "relates_to", "contradicts", "requires_verification"]),
+        reasoning: zod_1.z.string(),
+    })).optional(),
+    additionalWarnings: zod_1.z.array(zod_1.z.object({
+        title: zod_1.z.string(),
+        description: zod_1.z.string(),
+        severity: zod_1.z.enum(["low", "medium", "high"]),
+        relatedRule: zod_1.z.string().optional(),
+        suggestion: zod_1.z.string(),
+    })).optional(),
+    additionalCritical: zod_1.z.array(zod_1.z.object({
+        title: zod_1.z.string(),
+        description: zod_1.z.string(),
+        impact: zod_1.z.string(),
+        blocking: zod_1.z.boolean(),
+        relatedRule: zod_1.z.string().optional(),
+        suggestedFix: zod_1.z.string(),
+    })).optional(),
+    designDiscrepancies: zod_1.z.array(zod_1.z.object({
+        section: zod_1.z.string(),
+        expected: zod_1.z.string(),
+        actual: zod_1.z.string(),
+        severity: zod_1.z.enum(["low", "medium", "high", "critical"]),
+        fix: zod_1.z.string(),
+    })).optional(),
+    predictedRisks: zod_1.z.array(zod_1.z.object({
+        title: zod_1.z.string(),
+        description: zod_1.z.string(),
+        likelihood: zod_1.z.enum(["low", "medium", "high"]),
+        impact: zod_1.z.enum(["low", "medium", "high", "critical"]),
+        mitigation: zod_1.z.string(),
+    })).optional(),
+    verificationNeeded: zod_1.z.array(zod_1.z.object({
+        title: zod_1.z.string(),
+        description: zod_1.z.string(),
+        type: zod_1.z.enum(["visual", "functional", "manual", "automated"]),
+        url: zod_1.z.string().optional(),
+        selector: zod_1.z.string().optional(),
+        expectedBehavior: zod_1.z.string(),
+        authContext: zod_1.z.string().optional(),
+        headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    })).optional(),
+    summary: zod_1.z.string(),
+    nextSteps: zod_1.z.array(zod_1.z.string()),
+});
+class SolveComplexTool extends tool_base_class_1.ToolBase {
+    config;
+    name = "solveComplex";
+    description = "Advanced problem-solving tool for complex tasks with deep dependencies. " +
+        "Use this when a task has many interconnected parts that need systematic decomposition. " +
+        "Creates a dynamic dependency tree, fetches relevant resources at each level, " +
+        "predicts potential issues, and returns structured findings including warnings, " +
+        "critical issues, design compliance, risks, and verification tasks. " +
+        "The tree grows iteratively - call multiple times as new dependencies are discovered. " +
+        "Supports streaming progress via emitProgress. " +
+        "Use when: task is too complex for simple reasoning, many interdependencies exist, " +
+        "need to verify against design/rules, want comprehensive analysis beyond the immediate fix.";
+    namespace = "planning";
+    tags = ["reasoning", "analysis", "planning"];
+    readonly = true;
+    trees = new Map();
+    constructor(config = {}) {
+        super(zod_1.z.object({
+            problem: zod_1.z.string().describe("Full description of the complex problem to solve"),
+            context: zod_1.z.array(zod_1.z.string()).optional()
+                .describe("Context documents: design specs, rules, business plans, architecture docs"),
+            maxDepth: zod_1.z.number().int().min(1).max(5).optional().default(3)
+                .describe("Maximum recursion depth for dependency tree (1-5, default 3)"),
+            maxNodes: zod_1.z.number().int().min(5).max(100).optional().default(50)
+                .describe("Maximum total nodes in the tree (5-100, default 50)"),
+            targetFiles: zod_1.z.array(zod_1.z.string()).optional()
+                .describe("Files directly involved in the problem"),
+            constraints: zod_1.z.array(zod_1.z.string()).optional()
+                .describe("Specific constraints or rules that must be satisfied"),
+            scope: zod_1.z.enum(["full", "focused", "exploratory"]).optional().default("full")
+                .describe("Analysis scope: full (comprehensive), focused (targeted), exploratory (broad search)"),
+            treeId: zod_1.z.string().optional().describe("Continue building an existing tree. Creates new if not provided."),
+        }));
+        this.config = config;
+    }
+    async run(input, ctx) {
+        const problem = input["problem"];
+        const context = input["context"];
+        const maxDepth = input["maxDepth"] ?? 3;
+        const maxNodes = input["maxNodes"] ?? 50;
+        const targetFiles = input["targetFiles"];
+        const constraints = input["constraints"];
+        const scope = input["scope"] ?? "full";
+        const treeId = input["treeId"];
+        ctx.emitProgress?.(`Solving complex problem: "${problem.slice(0, this.config.truncation?.progressMsgChars ?? 100)}"`, { scope, maxDepth });
+        // Get or create tree
+        const tree = await this.getOrCreateTree(treeId);
+        const existingRoot = tree.getRootProblemId();
+        // Create root problem if starting new
+        let rootNode = existingRoot ? tree.getNode(existingRoot) : undefined;
+        if (!rootNode) {
+            rootNode = tree.addRootProblem(problem.slice(0, this.config.truncation?.rootTitleChars ?? 120), problem);
+            ctx.emitProgress?.(`Root problem created: ${rootNode.id}`);
+        }
+        else {
+            ctx.emitProgress?.(`Continuing existing tree: ${rootNode.id}`, { existingNodes: tree.getAllNodes().length });
+        }
+        // Check if we have LLM access for decomposition
+        const callStructured = ctx.conversation?.callStructured;
+        if (!callStructured) {
+            return this.buildNoLLMResult(tree, rootNode, problem, context);
+        }
+        try {
+            // Build decomposition prompt
+            const prompt = this.buildDecompositionPrompt(problem, context, constraints, targetFiles, scope, tree, rootNode.id, maxDepth);
+            ctx.emitProgress?.("Decomposing problem via LLM analysis...");
+            const result = await callStructured(prompt, DecompositionSchema);
+            ctx.emitProgress?.("LLM decomposition complete", { subProblemCount: result.subProblems.length });
+            // Build tree from decomposition - depth 0 children
+            const nodeMap = new Map(); // title → nodeId
+            for (const sub of result.subProblems) {
+                if (tree.getAllNodes().length >= maxNodes) {
+                    ctx.emitProgress?.("Max nodes reached, stopping tree expansion", { maxNodes });
+                    break;
+                }
+                const child = tree.addChildNode(rootNode.id, sub.type, sub.title, sub.description, sub.confidence);
+                if (child) {
+                    nodeMap.set(sub.title, child.id);
+                    if (sub.predictedIssues) {
+                        for (const issue of sub.predictedIssues) {
+                            tree.addPredictedIssue(child.id, issue);
+                        }
+                    }
+                    tree.updateNodeStatus(child.id, "analyzing");
+                    // Adaptive lookup at depth 1 for this sub-problem
+                    await this.doAdaptiveLookup(child, sub.searchTerms, ctx);
+                }
+            }
+            // Add cross-dependencies as edges
+            if (result.crossDependencies) {
+                for (const cd of result.crossDependencies) {
+                    const fromId = nodeMap.get(cd.from);
+                    const toId = nodeMap.get(cd.to);
+                    if (fromId && toId) {
+                        tree.addEdge(fromId, toId, cd.type, cd.reasoning, 0.7);
+                    }
+                }
+            }
+            // Recursive deeper decomposition (depth 2+)
+            if (maxDepth >= 2) {
+                ctx.emitProgress?.("Starting deeper analysis...");
+                for (const [title, nodeId] of nodeMap) {
+                    if (tree.getAllNodes().length >= maxNodes)
+                        break;
+                    const node = tree.getNode(nodeId);
+                    if (!node)
+                        continue;
+                    if (node.depth >= maxDepth)
+                        continue;
+                    ctx.emitProgress?.(`Deeper analysis: ${title}`, { nodeId, depth: node.depth });
+                    try {
+                        const deeperPrompt = this.buildDeeperPrompt(node, tree, constraints, context);
+                        const deeperResult = await callStructured(deeperPrompt, zod_1.z.object({
+                            deeperIssues: zod_1.z.array(SubProblemSchema).optional(),
+                            relatedNotes: zod_1.z.string().optional(),
+                            newDependencies: zod_1.z.array(zod_1.z.string()).optional(),
+                        }));
+                        if (deeperResult.deeperIssues && deeperResult.deeperIssues.length > 0) {
+                            for (const issue of deeperResult.deeperIssues) {
+                                if (tree.getAllNodes().length >= maxNodes)
+                                    break;
+                                const child = tree.addChildNode(nodeId, issue.type, issue.title, issue.description, issue.confidence);
+                                if (child) {
+                                    if (issue.predictedIssues) {
+                                        for (const pi of issue.predictedIssues) {
+                                            tree.addPredictedIssue(child.id, pi);
+                                        }
+                                    }
+                                    await this.doAdaptiveLookup(child, issue.searchTerms, ctx);
+                                }
+                            }
+                        }
+                        if (result.crossDependencies && deeperResult.newDependencies) {
+                            for (const depTitle of deeperResult.newDependencies) {
+                                const depId = nodeMap.get(depTitle);
+                                if (depId && depId !== nodeId) {
+                                    tree.addEdge(nodeId, depId, "relates_to", "Deeper analysis discovery", 0.5);
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        ctx.emitProgress?.(`Deeper analysis failed for: ${title}`, { nodeId });
+                    }
+                }
+            }
+            // Build structured output
+            const output = this.buildOutput(tree, rootNode.id, problem, result, nodeMap);
+            ctx.emitProgress?.("Analysis complete", {
+                totalNodes: output.treeState.stats.totalNodes,
+                dependencies: output.analysis.discoveredDependencies.length,
+                warnings: output.analysis.additionalWarnings.length,
+                criticals: output.analysis.additionalCritical.length,
+            });
+            // Persist tree snapshot if storage configured
+            this.persistTree(tree).catch(() => { });
+            return {
+                success: true,
+                output: JSON.stringify(output, null, 2),
+                data: { result: output },
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            ctx.emitProgress?.(`LLM decomposition failed: ${errorMsg}`);
+            return this.buildNoLLMResult(tree, rootNode, problem, context);
+        }
+    }
+    buildDecompositionPrompt(problem, context, constraints, targetFiles, scope, tree, rootId, maxDepth) {
+        const t = this.config.truncation ?? {};
+        const ctxChars = t.contextDocChars ?? 500;
+        const pt = this.config.promptTemplates ?? {};
+        const parts = [];
+        parts.push(pt.decompositionPersona ??
+            "You are an expert problem-solving analyst. Your task is to decompose a complex problem into its constituent parts, identify deep dependencies, and predict potential issues.");
+        parts.push(`\n## Problem to Decompose\n${problem}`);
+        if (constraints && constraints.length > 0) {
+            parts.push(`\n## Constraints\n${constraints.map((c) => `- ${c}`).join("\n")}`);
+        }
+        if (targetFiles && targetFiles.length > 0) {
+            parts.push(`\n## Target Files\n${targetFiles.join("\n")}`);
+        }
+        if (context && context.length > 0) {
+            parts.push(`\n## Context Documents\n${context.map((c) => `- ${c.slice(0, ctxChars)}`).join("\n\n")}`);
+        }
+        const existingContext = tree.toContextString();
+        if (existingContext) {
+            parts.push(`\n## Current Problem Tree State\n${existingContext}`);
+        }
+        parts.push(`\n## Instructions`);
+        parts.push(`Scope: ${scope}`);
+        parts.push(`Max depth: ${maxDepth}`);
+        parts.push(``);
+        if (pt.decompositionInstructions) {
+            parts.push(pt.decompositionInstructions);
+        }
+        else {
+            const checklist = pt.crossCuttingChecklist ?? DEFAULT_CROSS_CUTTING;
+            parts.push(`IMPORTANT: Think beyond the immediate fix. Consider:`);
+            parts.push(`1. DIRECT dependencies — what this problem directly affects or is affected by`);
+            parts.push(`2. TRANSITIVE dependencies — second-order and third-order effects`);
+            parts.push(`3. CROSS-CUTTING concerns: ${checklist.join("; ")}`);
+            parts.push(`4. DESIGN/RULES compliance — check against provided context documents`);
+            parts.push(`5. PREDICTED risks — what could go wrong, edge cases`);
+            parts.push(`6. VISUAL verification needs — what needs browser/visual confirmation`);
+            parts.push(``);
+            parts.push(`For each sub-problem, include specific search terms that would help find relevant documentation.`);
+            parts.push(`Return the complete structured JSON output.`);
+        }
+        return parts.join("\n");
+    }
+    buildDeeperPrompt(node, tree, constraints, context) {
+        const pt = this.config.promptTemplates ?? {};
+        const parts = [];
+        parts.push(pt.deeperAnalysisPersona ??
+            "You are analyzing a specific sub-problem in detail to find deeper issues.");
+        parts.push(`\n## Sub-Problem\nTitle: ${node.title}\nDescription: ${node.description}`);
+        parts.push(`Type: ${node.type}, Confidence: ${Math.round(node.confidence * 100)}%`);
+        if (node.predictedIssues.length > 0) {
+            parts.push(`\n### Predicted Issues\n${node.predictedIssues.map((i) => `- ${i}`).join("\n")}`);
+        }
+        const children = tree.getChildren(node.id);
+        if (children.length > 0) {
+            parts.push(`\n### Existing Sub-Issues\n${children.map((c) => `- [${c.type}] ${c.title}`).join("\n")}`);
+        }
+        if (constraints && constraints.length > 0) {
+            parts.push(`\n## Constraints\n${constraints.join("\n")}`);
+        }
+        if (pt.deeperAnalysisInstructions) {
+            parts.push(pt.deeperAnalysisInstructions);
+        }
+        else {
+            parts.push(`\nFind deeper issues, edge cases, implementation details, and anything that could go wrong.`);
+        }
+        return parts.join("\n");
+    }
+    async doAdaptiveLookup(node, searchTerms, ctx) {
+        if (!this.config.lookupTool)
+            return;
+        try {
+            const lookupResult = await this.config.lookupTool.run({
+                problemContext: `${node.title}: ${node.description}`,
+                depth: node.depth,
+                nodeType: node.type,
+                searchTerms,
+                maxResults: 3,
+            }, ctx);
+            if (lookupResult.success && lookupResult.data) {
+                const data = lookupResult.data;
+                const resources = data.result?.resources ?? [];
+                const nodeTree = this.getTreeForNode(node);
+                for (const res of resources) {
+                    if (res.entryId && nodeTree) {
+                        nodeTree.addSourceResource(node.id, res.entryId);
+                    }
+                }
+            }
+        }
+        catch {
+            // Adaptive lookup failure is non-fatal
+        }
+    }
+    buildOutput(tree, rootId, problem, decomposition, nodeMap) {
+        const root = tree.getNode(rootId);
+        const allNodes = tree.getAllNodes();
+        const allDeps = decomposition.subProblems.filter((sp) => sp.type === "dependency");
+        const severityThresh = this.config.scoring?.severityThresholds ?? {};
+        const critThresh = severityThresh.critical ?? 0.8;
+        const highThresh = severityThresh.high ?? 0.6;
+        const discoveredDependencies = allDeps
+            .map((sp) => ({
+            nodeId: nodeMap.get(sp.title) ?? "",
+            title: sp.title,
+            description: sp.description,
+            impactArea: sp.title.split(" ").slice(0, 3).join(" "),
+            severity: sp.confidence > critThresh ? "critical" : sp.confidence > highThresh ? "high" : "medium",
+            evidenceRefs: [],
+        }));
+        const proposedSolutions = decomposition.subProblems
+            .filter((sp) => sp.type === "solution")
+            .map((sp) => ({
+            nodeId: nodeMap.get(sp.title) ?? "",
+            title: sp.title,
+            description: sp.description,
+            steps: sp.predictedIssues ?? [sp.description],
+            prerequisitesNodeIds: (sp.dependencies ?? [])
+                .map((d) => nodeMap.get(d) ?? "")
+                .filter(Boolean),
+            estimatedComplexity: "moderate",
+            confidence: sp.confidence,
+        }));
+        const warnings = (decomposition.additionalWarnings ?? []).map((w) => ({
+            sourceNodeId: rootId,
+            title: w.title,
+            description: w.description,
+            severity: w.severity,
+            relatedRule: w.relatedRule,
+            suggestion: w.suggestion,
+        }));
+        const criticalIssues = (decomposition.additionalCritical ?? []).map((c) => ({
+            sourceNodeId: rootId,
+            title: c.title,
+            description: c.description,
+            impact: c.impact,
+            blocking: c.blocking,
+            relatedRule: c.relatedRule,
+            suggestedFix: c.suggestedFix,
+        }));
+        const designDiscrepancies = decomposition.designDiscrepancies ?? [];
+        const predictedRisks = (decomposition.predictedRisks ?? []).map((r) => ({
+            sourceNodeId: rootId,
+            title: r.title,
+            description: r.description,
+            likelihood: r.likelihood,
+            impact: r.impact,
+            mitigation: r.mitigation,
+            relatedNodes: [],
+        }));
+        const verificationTasks = (decomposition.verificationNeeded ?? []).map((v) => ({
+            nodeId: rootId,
+            title: v.title,
+            description: v.description,
+            type: v.type,
+            url: v.url,
+            selector: v.selector,
+            expectedBehavior: v.expectedBehavior,
+            authContext: v.authContext,
+            headers: v.headers,
+        }));
+        const unresolvedCount = allNodes.filter((n) => n.status !== "resolved" && n.status !== "verified").length;
+        return {
+            rootProblemId: rootId,
+            analysis: {
+                directTarget: problem,
+                discoveredDependencies,
+                proposedSolutions,
+                additionalWarnings: warnings,
+                additionalCritical: criticalIssues,
+                designCompliance: {
+                    overallScore: designDiscrepancies.length === 0 ? 1 : Math.max(0, 1 - designDiscrepancies.length * (this.config.scoring?.compliancePenaltyPerDiscrepancy ?? 0.2)),
+                    sections: designDiscrepancies.map((d) => ({
+                        section: d.section,
+                        status: d.severity === "critical" ? "non_compliant" : d.severity === "high" ? "partial" : "compliant",
+                        details: `${d.expected} vs ${d.actual}`,
+                        evidenceRefs: [],
+                    })),
+                    discrepancies: designDiscrepancies,
+                },
+                predictedRisks,
+                verificationNeeded: verificationTasks,
+            },
+            treeState: tree.snapshot(),
+            summary: decomposition.summary,
+            nextSteps: decomposition.nextSteps,
+            unresolvedCount,
+        };
+    }
+    buildNoLLMResult(tree, root, problem, _context) {
+        const keywords = problem.toLowerCase();
+        const guessedIssues = [];
+        // Use configurable heuristic rules, fall back to built-in defaults
+        const rules = (this.config.heuristicRules && this.config.heuristicRules.length > 0)
+            ? this.config.heuristicRules
+            : DEFAULT_HEURISTIC_RULES;
+        for (const rule of rules) {
+            if (rule.keywords.some((kw) => keywords.includes(kw.toLowerCase()))) {
+                for (const issue of rule.issues) {
+                    guessedIssues.push({ type: issue.type, title: issue.title, desc: issue.desc });
+                }
+            }
+        }
+        // Add configurable cross-cutting concerns
+        const crossCutting = (this.config.heuristicCrossCutting && this.config.heuristicCrossCutting.length > 0)
+            ? this.config.heuristicCrossCutting
+            : [
+                { type: "risk", title: "Tests need updating", desc: "Unit/integration/e2e tests may need changes for the new behavior" },
+                { type: "risk", title: "Documentation drift", desc: "README, API docs, or onboarding guides may become outdated" },
+                { type: "dependency", title: "Dependency updates", desc: "May require updating imported modules or shared utilities" },
+            ];
+        for (const cc of crossCutting) {
+            guessedIssues.push({ type: cc.type, title: cc.title, desc: cc.desc });
+        }
+        const maxNodes = this.config.heuristicMaxNodes ?? 20;
+        for (const issue of guessedIssues) {
+            if (tree.getAllNodes().length < maxNodes) {
+                tree.addChildNode(root.id, issue.type, issue.title, issue.desc, 0.5);
+            }
+        }
+        const snapshot = tree.snapshot();
+        const output = {
+            rootProblemId: root.id,
+            analysis: {
+                directTarget: problem,
+                discoveredDependencies: guessedIssues
+                    .filter((i) => i.type === "dependency")
+                    .map((i) => ({
+                    nodeId: "", title: i.title, description: i.desc,
+                    impactArea: "", severity: "medium", evidenceRefs: [],
+                })),
+                proposedSolutions: [],
+                additionalWarnings: [{
+                        sourceNodeId: root.id,
+                        title: "Heuristic analysis only",
+                        description: "No LLM available for deep decomposition. Results are keyword-based estimates.",
+                        severity: "medium",
+                        suggestion: "Connect an LLM adapter for comprehensive analysis.",
+                    }],
+                additionalCritical: [],
+                designCompliance: { overallScore: 0, sections: [], discrepancies: [] },
+                predictedRisks: guessedIssues
+                    .filter((i) => i.type === "risk")
+                    .map((r) => ({
+                    sourceNodeId: root.id, title: r.title, description: r.desc,
+                    likelihood: "medium", impact: "medium",
+                    mitigation: "Review and test before deployment", relatedNodes: [],
+                })),
+                verificationNeeded: [],
+            },
+            treeState: snapshot,
+            summary: `Heuristic analysis: ${guessedIssues.length} potential sub-issues identified. Deep LLM analysis recommended for production use.`,
+            nextSteps: guessedIssues.map((g) => `Investigate: ${g.title}`),
+            unresolvedCount: guessedIssues.length,
+        };
+        this.persistTree(tree).catch(() => { });
+        return {
+            success: true,
+            output: JSON.stringify(output, null, 2),
+            data: { result: output },
+        };
+    }
+    async getOrCreateTree(treeId) {
+        const id = treeId ?? "default";
+        let tree = this.trees.get(id);
+        if (!tree) {
+            // Try loading from storage first
+            const loaded = await this.loadTree(id);
+            tree = loaded ?? undefined;
+            if (!tree) {
+                tree = new problem_tree_class_1.ProblemTree();
+            }
+            this.trees.set(id, tree);
+        }
+        return tree;
+    }
+    async loadTree(treeId) {
+        if (!this.config.storage)
+            return null;
+        try {
+            const stored = await this.config.storage.read(treeId);
+            if (stored) {
+                return problem_tree_class_1.ProblemTree.fromSnapshot(stored);
+            }
+        }
+        catch {
+            // Storage load failure is non-fatal
+        }
+        return null;
+    }
+    async persistTree(tree) {
+        if (!this.config.storage)
+            return;
+        try {
+            const snapshot = { ...tree.snapshot(), id: tree.getTreeId() };
+            // Use update (upsert pattern); if not found, pre-seed then update
+            try {
+                await this.config.storage.update(tree.getTreeId(), snapshot);
+            }
+            catch {
+                // Entry doesn't exist — create with empty content then update
+                await this.config.storage.create({ id: tree.getTreeId() });
+                await this.config.storage.update(tree.getTreeId(), snapshot);
+            }
+        }
+        catch {
+            // Storage persistence failure is non-fatal
+        }
+    }
+    getTreeForNode(node) {
+        for (const tree of this.trees.values()) {
+            if (tree.getNode(node.id))
+                return tree;
+        }
+        return null;
+    }
+}
+exports.SolveComplexTool = SolveComplexTool;
+//# sourceMappingURL=solve-complex.tool.js.map