@doquflow/server 1.6.0 → 2.0.0

package/dist/extractor-stoplist.js

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENTITY_STOPLIST = void 0;
-/**
- * Stop-list for wiki entity extraction.
- * Any candidate whose normalized form appears here is rejected as a generic term
- * that adds noise without semantic value.
- *
- * Applied as single-word match AND whole-phrase match. Multi-word phrases
- * where every word is on this list are also rejected (see ruleStopList).
- */
-exports.ENTITY_STOPLIST = new Set([
-    // Generic quantifiers / determiners
-    "any", "all", "some", "each", "every", "one", "two", "three", "four", "five",
-    "none", "both", "either", "other", "another", "several", "many", "few",
-    // Conjunctions / prepositions / filler / connectors
-    "the", "and", "or", "for", "with", "from", "into", "onto", "over", "under",
-    "then", "when", "while", "where", "which", "what", "who", "why", "how",
-    "that", "this", "these", "those", "here", "there", "of", "in", "on", "at",
-    "to", "by", "as", "is", "are", "was", "were", "be", "been", "being",
-    // Modal / auxiliary verbs
-    "can", "will", "shall", "would", "could", "should", "must", "may", "might",
-    "also", "just", "only", "even", "already", "still", "yet", "more",
-    // Boolean / status tokens
-    "true", "false", "yes", "no", "ok", "done", "todo",
-    // Common vague action words
-    "add", "added", "remove", "removed", "update", "updated",
-    "change", "changed", "fix", "fixed", "use", "used", "get", "set",
-    "allow", "allowed", "block", "blocked", "enable", "enabled", "disable", "disabled",
-    "create", "created", "build", "built", "run", "ran", "make", "made",
-    "show", "shows", "display", "displayed", "include", "included",
-    // Generic noun noise
-    "active", "audience", "behavior", "behaviour", "benefits", "binary",
-    "append", "approval", "audit", "auditable",
-    "note", "notes", "type", "types", "item", "items", "list", "value", "values",
-    "option", "options", "example", "examples", "result", "results",
-    "output", "outputs", "input", "inputs", "data", "info", "information",
-    "step", "steps", "section", "sections", "part", "parts", "content",
-    // Section-heading boilerplate (single words)
-    "architecture", "overview", "purpose", "documentation", "installation",
-    "commands", "components", "configuration", "management", "registration",
-    "views", "view", "iteration", "iterations",
-    "summary", "introduction", "background", "context", "scope", "rationale",
-    "goals", "goal", "motivation", "definition", "definitions", "terminology",
-    "implementation", "design", "approach", "methodology", "method", "methods",
-    "usage", "setup", "tutorial", "guide", "guides", "reference",
-    "requirements", "dependencies", "prerequisites", "features", "feature",
-    "categories", "category", "kind", "kinds",
-    "workflow", "workflows", "pipeline", "pipelines",
-    "system", "systems", "module", "modules", "package", "packages",
-    "service", "services", "interface", "interfaces", "layer", "layers",
-    "support", "supports", "supported", "available", "current",
-    // Common section adjectives (combined with stop nouns → all-stop phrase rejected)
-    "key", "core", "main", "primary", "secondary", "general", "basic", "advanced",
-    "common", "typical", "standard", "default", "custom", "specific", "generic",
-    "new", "old", "next", "previous", "first", "last", "final", "initial",
-    // Doc-structure terms
-    "title", "abstract", "outline", "table", "figure", "diagram", "appendix",
-    "footnote", "footnotes", "see", "above", "below",
-    // Common project section phrases (multi-word, exact match)
-    "getting started", "next steps", "key components", "key commands",
-    "core modules", "core components", "core types", "tech stack",
-    "technology stack", "use case", "use cases", "see also", "edge cases",
-    "acceptance criteria", "test scenarios", "testing results",
-    "implementation status", "implementation steps", "files to touch",
-    "format options", "format purity", "data flow", "data storage",
-    "entry point", "output includes", "step by step",
-    "command pattern", "tool pattern", "document type", "release history",
-    "design principles", "security considerations",
-    "global flags", "environment variables", "flag normalization",
-    "filename validation", "commit deduplication", "commit message format",
-    "create update", "find contradictions", "find gaps", "find orphans", "find stale",
-    "build pipeline", "ci cd", "ci cd pipeline", "github actions workflow",
-    "github actions integration", "version controlled", "version injection",
-    "deployment to release repo", "readme integration",
-    "lessons learned applied to docuflow", "specific wiki pages for docuflow",
-    "wiki maintenance for docuflow", "wiki pipeline tools", "codebase scanner tools",
-    "health guidance tools", "tool categories summary", "package responsibilities",
-    "component architecture", "monorepo overview", "package architecture",
-    "phase 2 testing", "initial setup", "ingest workflow", "query workflow",
-    "lint workflow", "related entities", "agent integration",
-    "integration with docuflow", "mcp registration",
-    "project context", "project auto discovery", "provider detection",
-    "silent fallback warning", "reviewer verdict format", "task spec format",
-    "reusable skill", "supported languages",
-    "what it detects", "what it does", "what it shows", "what starts",
-    "concepts ideas", "entities things", "syntheses analyses", "timelines events",
-    "graph tool", "format options",
-]);

package/dist/extractor.js

@@ -1,171 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract = extract;
-function uniq(arr) {
-    return Array.from(new Set(arr.filter((s) => s && s.length > 0)));
-}
-function collect(re, content, group = 1) {
-    const out = [];
-    let m;
-    while ((m = re.exec(content)) !== null) {
-        if (m[group])
-            out.push(m[group]);
-    }
-    return out;
-}
-const RE_CLASS = /(?:abstract\s+|sealed\s+|partial\s+|public\s+|private\s+|protected\s+|internal\s+|static\s+)*(?:class|interface|struct|enum|record)\s+([A-Z]\w*)/g;
-const RE_FUNC_KW = /(?:public|private|protected|internal|static|async|override|function|def|fn|sub)\s+(?:[\w<>\[\],?\s]+?\s+)?([A-Za-z_]\w*)\s*\(/g;
-const RE_FUNC_ARROW = /\b([A-Za-z_]\w*)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g;
-const RE_METHOD_TS = /^\s*(?:public|private|protected|static|async|readonly|\s)*([a-z_]\w*)\s*\([^)]*\)\s*[:{]/gm;
-const RE_USING = /\busing\s+([\w.]+)\s*;/g;
-const RE_IMPORT_FROM = /\bimport\s+(?:[\w*${}\s,]+\s+from\s+)?['"]([^'"]+)['"]/g;
-const RE_REQUIRE = /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g;
-const RE_DECORATOR = /@(Injectable|Component|Inject|Service|Module|Directive|Pipe|NgModule|Controller)\b/g;
-const RE_NEW_CLASS = /\bnew\s+([A-Z]\w*)\s*\(/g;
-// Standard SQL FROM/JOIN/INTO/UPDATE/DELETE patterns.
-const RE_SQL_TABLE = /(?:\bFROM|\bJOIN|\bINTO|\bUPDATE|\bDELETE\s+FROM|\bTABLE)\s+([A-Za-z_][\w.]*)/gi;
-// EF / ORM DbSet<T> declaration.
-const RE_DBSET = /\bDbSet<\s*([A-Z]\w*)\s*>/g;
-// Attribute-based table mapping: [Table("name")] and .Table("name")
-const RE_TABLE_ATTR = /\[Table\(\s*["']([^"']+)["']/g;
-const RE_TABLE_FLUENT = /\.Table\(\s*["']([^"']+)["']\s*\)/g;
-// EF DbContext property access: _db.Orders., context.Users., _repository.Items. etc.
-// Catches patterns like `_db.Orders.ToListAsync()`, `_context.Users.Find(id)`.
-const RE_EF_PROP = /\b(?:_?db|_?context|_?ctx|_?repository|_?repo)\s*\.\s*([A-Z]\w+)(?=[\s.(])/g;
-const RE_DOTNET_ROUTE = /\[(?:Route|Http(?:Get|Post|Put|Delete|Patch))\(\s*["']([^"']*)["']/g;
-const RE_MIN_API = /\bapp\.Map(?:Get|Post|Put|Delete|Patch)\s*\(\s*["']([^"']+)["']/g;
-const RE_EXPRESS = /\b(?:router|app)\.(?:get|post|put|delete|patch|use)\s*\(\s*['"]([^'"]+)['"]/g;
-const RE_NEST = /@(?:Get|Post|Put|Delete|Patch)\s*\(\s*['"]([^'"]+)['"]/g;
-const RE_NG_PATH = /\bpath\s*:\s*['"]([^'"]+)['"]/g;
-// Flask: @app.route('/path') @bp.route('/path')
-const RE_FLASK = /@\w+\.route\s*\(\s*['"]([^'"]+)['"]/g;
-// FastAPI / Flask-style: @app.get('/x') @router.post('/x')
-const RE_FASTAPI = /@(?:app|router|bp)\s*\.\s*(?:get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]/g;
-// Django: path('url/', view) url('pattern/', view)
-const RE_DJANGO = /\bpath\s*\(\s*['"]([^'"]+)['"]/g;
-const RE_CFG_CONNSTR = /\bConnectionStrings:([\w.]+)/g;
-const RE_PROCESS_ENV = /\bprocess\.env\.([A-Z_][A-Z0-9_]*)/g;
-const RE_DOTNET_ENV = /\bEnvironment\.GetEnvironmentVariable\(\s*["']([^"']+)["']/g;
-const RE_ICONFIG = /\bIConfiguration\b/g;
-const RE_APPSETTINGS = /\bappsettings(?:\.[A-Za-z0-9]+)?\.json\b/g;
-// ─── Go ─────────────────────────────────────────────────────────────────────
-// type FooBar struct | type FooBar interface
-const RE_GO_TYPE = /\btype\s+([A-Z]\w*)\s+(?:struct|interface)/g;
-// func FuncName( or func (recv *Type) MethodName(
-const RE_GO_FUNC = /\bfunc\s+(?:\([^)]+\)\s+)?([A-Za-z_]\w*)\s*\(/g;
-// import "pkg" or import ( "pkg" ) — individual quoted paths inside import blocks
-const RE_GO_IMPORT = /^\s+["']([^"'\s]+)["']\s*(?:\/\/.*)?$/gm;
-// os.Getenv("KEY") or os.LookupEnv("KEY")
-const RE_GO_ENV = /\bos\.(?:Getenv|LookupEnv)\s*\(\s*["']([A-Z_][A-Z0-9_]*)["']/g;
-// gorilla/mux, gin, chi, echo, stdlib: router.GET("/path", ...)
-const RE_GO_HTTP = /\b(?:r|router|e|mux|g|app)\s*\.\s*(?:HandleFunc|GET|POST|PUT|DELETE|PATCH|Handle|Any)\s*\(\s*["']([^"']+)["']/g;
-// GORM explicit table: db.Table("name")
-const RE_GO_GORM_TABLE = /\bdb\s*\.\s*Table\s*\(\s*["']([^"']+)["']/g;
-// ─── Ruby / Rails ────────────────────────────────────────────────────────────
-// class Foo or module Bar
-const RE_RUBY_CLASS = /\b(?:class|module)\s+([A-Z]\w*(?:::[A-Z]\w*)*)/g;
-// def method_name or def self.method_name
-const RE_RUBY_DEF = /^\s*def\s+(?:self\.)?([a-z_]\w*)/gm;
-// require 'gem' or require_relative '../path'
-const RE_RUBY_REQUIRE = /\brequire(?:_relative)?\s+["']([^"']+)["']/g;
-// ENV['KEY'] or ENV["KEY"]
-const RE_RUBY_ENV = /\bENV\s*\[\s*["']([A-Z_][A-Z0-9_]*)["']\s*\]/g;
-// Rails routes: get '/path', post '/path', resources :users, root 'home#index'
-const RE_RAILS_ROUTE = /^\s*(?:get|post|put|delete|patch|resources|resource|root)\s+["']([^"']+)["']/gm;
-// ActiveRecord associations: has_many :users, belongs_to :user
-const RE_AR_HAS = /\bhas_(?:many|one)\s+:(\w+)/g;
-const RE_AR_BELONGS = /\bbelongs_to\s+:(\w+)/g;
-// Explicit table name: self.table_name = 'table'
-const RE_AR_TABLE = /\bself\.table_name\s*=\s*["']([^"']+)["']/g;
-// SQL keywords and noise that the regex may pick up as table names.
-// Also strips single-letter hits (LINQ aliases: `from u in _db.Users` → u).
-const SQL_KEYWORD_NOISE = new Set([
-    "select", "where", "set", "on", "as", "by", "in", "is", "not", "null",
-    "and", "or", "top", "all", "any", "exists", "between", "like", "case",
-    "when", "then", "else", "end", "with", "having", "group", "order",
-    "asc", "desc", "distinct", "outer", "inner", "left", "right", "full",
-    "cross", "natural", "values", "default", "primary", "key", "index",
-]);
-// EF DbContext property names that are framework plumbing, not tables.
-const EF_NOISE = new Set([
-    "SaveChanges", "SaveChangesAsync", "Entry", "Add", "AddRange", "Remove",
-    "RemoveRange", "Update", "UpdateRange", "Attach", "Find", "FindAsync",
-    "FromSqlRaw", "FromSqlInterpolated", "Database", "Model", "ChangeTracker",
-    "Configuration", "ToList", "ToListAsync", "FirstOrDefault", "FirstOrDefaultAsync",
-    "Where", "Any", "Count", "Include", "ThenInclude", "OrderBy", "GroupBy", "Select",
-]);
-function cleanTableNames(names) {
-    return names.filter((n) => {
-        if (n.length < 2)
-            return false;
-        if (SQL_KEYWORD_NOISE.has(n.toLowerCase()))
-            return false;
-        if (EF_NOISE.has(n))
-            return false;
-        return true;
-    });
-}
-function extract(content) {
-    const classes = uniq([
-        ...collect(new RegExp(RE_CLASS.source, "g"), content),
-        ...collect(new RegExp(RE_GO_TYPE.source, "g"), content),
-        ...collect(new RegExp(RE_RUBY_CLASS.source, "g"), content),
-    ]);
-    const functions = uniq([
-        ...collect(new RegExp(RE_FUNC_KW.source, "g"), content),
-        ...collect(new RegExp(RE_FUNC_ARROW.source, "g"), content),
-        ...collect(new RegExp(RE_METHOD_TS.source, "gm"), content),
-        ...collect(new RegExp(RE_GO_FUNC.source, "g"), content),
-        ...collect(new RegExp(RE_RUBY_DEF.source, "gm"), content),
-    ]).filter((n) => !["if", "for", "while", "switch", "catch", "return", "function"].includes(n));
-    const dependencies = uniq([
-        ...collect(new RegExp(RE_USING.source, "g"), content),
-        ...collect(new RegExp(RE_IMPORT_FROM.source, "g"), content),
-        ...collect(new RegExp(RE_REQUIRE.source, "g"), content),
-        ...collect(new RegExp(RE_DECORATOR.source, "g"), content),
-        ...collect(new RegExp(RE_NEW_CLASS.source, "g"), content),
-        ...collect(new RegExp(RE_GO_IMPORT.source, "gm"), content),
-        ...collect(new RegExp(RE_RUBY_REQUIRE.source, "g"), content),
-    ]);
-    const db_tables = uniq(cleanTableNames([
-        ...collect(new RegExp(RE_SQL_TABLE.source, "gi"), content),
-        ...collect(new RegExp(RE_DBSET.source, "g"), content),
-        ...collect(new RegExp(RE_TABLE_ATTR.source, "g"), content),
-        ...collect(new RegExp(RE_TABLE_FLUENT.source, "g"), content),
-        ...collect(new RegExp(RE_EF_PROP.source, "g"), content),
-        ...collect(new RegExp(RE_GO_GORM_TABLE.source, "g"), content),
-        ...collect(new RegExp(RE_AR_HAS.source, "g"), content),
-        ...collect(new RegExp(RE_AR_BELONGS.source, "g"), content),
-        ...collect(new RegExp(RE_AR_TABLE.source, "g"), content),
-    ]));
-    const endpoints = uniq([
-        ...collect(new RegExp(RE_DOTNET_ROUTE.source, "g"), content),
-        ...collect(new RegExp(RE_MIN_API.source, "g"), content),
-        ...collect(new RegExp(RE_EXPRESS.source, "g"), content),
-        ...collect(new RegExp(RE_NEST.source, "g"), content),
-        ...collect(new RegExp(RE_NG_PATH.source, "g"), content),
-        ...collect(new RegExp(RE_FLASK.source, "g"), content),
-        ...collect(new RegExp(RE_FASTAPI.source, "g"), content),
-        ...collect(new RegExp(RE_DJANGO.source, "g"), content),
-        ...collect(new RegExp(RE_GO_HTTP.source, "g"), content),
-        ...collect(new RegExp(RE_RAILS_ROUTE.source, "gm"), content),
-    ]);
-    const config_refs = [];
-    config_refs.push(...collect(new RegExp(RE_CFG_CONNSTR.source, "g"), content).map((s) => `ConnectionStrings:${s}`));
-    config_refs.push(...collect(new RegExp(RE_PROCESS_ENV.source, "g"), content).map((s) => `process.env.${s}`));
-    config_refs.push(...collect(new RegExp(RE_DOTNET_ENV.source, "g"), content));
-    config_refs.push(...collect(new RegExp(RE_GO_ENV.source, "g"), content).map((s) => `os.Getenv(${s})`));
-    config_refs.push(...collect(new RegExp(RE_RUBY_ENV.source, "g"), content).map((s) => `ENV[${s}]`));
-    if (RE_ICONFIG.test(content))
-        config_refs.push("IConfiguration");
-    if (RE_APPSETTINGS.test(content))
-        config_refs.push("appsettings.json");
-    return {
-        classes: uniq(classes),
-        functions: uniq(functions),
-        dependencies,
-        db_tables,
-        endpoints,
-        config_refs: uniq(config_refs),
-    };
-}

package/dist/filesystem.js

@@ -1,132 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.walk = walk;
-exports.isBinary = isBinary;
-exports.safeReadFile = safeReadFile;
-exports.ensureDir = ensureDir;
-exports.writeFileAtomic = writeFileAtomic;
-exports.readJsonIfExists = readJsonIfExists;
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
-const SKIP_DIRS = new Set([
-    "node_modules",
-    "vendor",
-    ".git",
-    ".svn",
-    ".hg",
-    "dist",
-    "build",
-    "bin",
-    "obj",
-    ".docuflow",
-    ".next",
-    ".nuxt",
-    "out",
-    "target",
-    ".venv",
-    "venv",
-    "__pycache__",
-]);
-const SKIP_FILE_PATTERNS = [
-    /\.min\.js$/i,
-    /\.min\.css$/i,
-    /\.map$/i,
-    /\.lock$/i,
-    /package-lock\.json$/i,
-];
-const MAX_FILE_BYTES = 300 * 1024;
-async function walk(root) {
-    const files = [];
-    const skipped = [];
-    const absRoot = node_path_1.default.resolve(root);
-    async function recurse(dir) {
-        let entries;
-        try {
-            entries = await promises_1.default.readdir(dir, { withFileTypes: true });
-        }
-        catch (e) {
-            skipped.push({ path: dir, reason: `readdir failed: ${e.message}` });
-            return;
-        }
-        for (const entry of entries) {
-            const full = node_path_1.default.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (SKIP_DIRS.has(entry.name))
-                    continue;
-                await recurse(full);
-            }
-            else if (entry.isFile()) {
-                if (SKIP_FILE_PATTERNS.some((re) => re.test(entry.name))) {
-                    skipped.push({ path: full, reason: "skipped by pattern" });
-                    continue;
-                }
-                let stat;
-                try {
-                    stat = await promises_1.default.stat(full);
-                }
-                catch (e) {
-                    skipped.push({ path: full, reason: `stat failed: ${e.message}` });
-                    continue;
-                }
-                if (stat.size > MAX_FILE_BYTES) {
-                    skipped.push({ path: full, reason: `file >300KB (${stat.size} bytes)` });
-                    continue;
-                }
-                files.push({ path: full, size: stat.size });
-            }
-        }
-    }
-    try {
-        const stat = await promises_1.default.stat(absRoot);
-        if (!stat.isDirectory()) {
-            skipped.push({ path: absRoot, reason: "not a directory" });
-            return { files, skipped };
-        }
-    }
-    catch (e) {
-        skipped.push({ path: absRoot, reason: `root stat failed: ${e.message}` });
-        return { files, skipped };
-    }
-    await recurse(absRoot);
-    return { files, skipped };
-}
-function isBinary(buf) {
-    const len = Math.min(buf.length, 512);
-    for (let i = 0; i < len; i++) {
-        if (buf[i] === 0)
-            return true;
-    }
-    return false;
-}
-async function safeReadFile(filePath) {
-    try {
-        const buf = await promises_1.default.readFile(filePath);
-        if (isBinary(buf)) {
-            return { size: buf.length, binary: true };
-        }
-        return { content: buf.toString("utf8"), size: buf.length };
-    }
-    catch (e) {
-        return { size: 0, error: e.message };
-    }
-}
-async function ensureDir(dir) {
-    await promises_1.default.mkdir(dir, { recursive: true });
-}
-async function writeFileAtomic(filePath, content) {
-    await ensureDir(node_path_1.default.dirname(filePath));
-    await promises_1.default.writeFile(filePath, content, "utf8");
-    return Buffer.byteLength(content, "utf8");
-}
-async function readJsonIfExists(filePath) {
-    try {
-        const txt = await promises_1.default.readFile(filePath, "utf8");
-        return JSON.parse(txt);
-    }
-    catch {
-        return null;
-    }
-}

package/dist/language-map.js

@@ -1,58 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extensionToLanguage = extensionToLanguage;
-const node_path_1 = __importDefault(require("node:path"));
-const EXT_MAP = {
-    ".cs": "csharp",
-    ".vb": "vbnet",
-    ".fs": "fsharp",
-    ".ts": "typescript",
-    ".tsx": "typescript",
-    ".js": "javascript",
-    ".jsx": "javascript",
-    ".mjs": "javascript",
-    ".cjs": "javascript",
-    ".php": "php",
-    ".java": "java",
-    ".py": "python",
-    ".rb": "ruby",
-    ".go": "go",
-    ".rs": "rust",
-    ".kt": "kotlin",
-    ".swift": "swift",
-    ".html": "html",
-    ".htm": "html",
-    ".cshtml": "razor",
-    ".razor": "razor",
-    ".vue": "vue",
-    ".css": "css",
-    ".scss": "scss",
-    ".sass": "sass",
-    ".less": "less",
-    ".json": "json",
-    ".xml": "xml",
-    ".yml": "yaml",
-    ".yaml": "yaml",
-    ".sql": "sql",
-    ".sh": "shell",
-    ".bash": "shell",
-    ".ps1": "powershell",
-    ".md": "markdown",
-    ".c": "c",
-    ".h": "c",
-    ".cpp": "cpp",
-    ".hpp": "cpp",
-    ".cc": "cpp",
-};
-function extensionToLanguage(filePath) {
-    const base = node_path_1.default.basename(filePath).toLowerCase();
-    // Angular pattern detection — checked first, before generic .ts.
-    if (base.endsWith(".component.ts") || base.endsWith(".service.ts") || base.endsWith(".module.ts") || base.endsWith(".directive.ts") || base.endsWith(".pipe.ts") || base.endsWith(".guard.ts")) {
-        return "angular";
-    }
-    const ext = node_path_1.default.extname(base);
-    return EXT_MAP[ext] ?? "unknown";
-}

package/dist/tools/answer-synthesis.js

@@ -1,189 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.synthesizeAnswer = synthesizeAnswer;
-const node_path_1 = __importDefault(require("node:path"));
-const filesystem_1 = require("../filesystem");
-/**
- * Extract key sentences from content that relate to the query
- */
-function extractRelevantSentences(content, queryTerms, maxSentences = 3) {
-    const sentences = content
-        .split(/[.!?]+/)
-        .map((s) => s.trim())
-        .filter((s) => s.length > 10 && !s.startsWith("#") && !s.startsWith("---"));
-    const scoredSentences = [];
-    for (const sentence of sentences) {
-        let score = 0;
-        const sentenceLower = sentence.toLowerCase();
-        for (const term of queryTerms) {
-            if (sentenceLower.includes(term)) {
-                // Count occurrences
-                const matches = sentenceLower.split(term).length - 1;
-                score += matches * 2;
-            }
-        }
-        if (score > 0) {
-            scoredSentences.push({ text: sentence, score });
-        }
-    }
-    // Sort by score and take top N
-    return scoredSentences
-        .sort((a, b) => b.score - a.score)
-        .slice(0, maxSentences)
-        .map((s) => s.text);
-}
-/**
- * Extract key concepts from page content (from H3 headers, bold text)
- */
-function extractKeyConcepts(content) {
-    const concepts = new Set();
-    // Extract from H3 headers
-    const h3Matches = content.matchAll(/^###\s+(.+?)$/gm);
-    for (const match of h3Matches) {
-        const concept = match[1].trim();
-        if (concept && concept.length < 80) {
-            concepts.add(concept);
-        }
-    }
-    // Extract from bold text (but not arrays/JSON)
-    const boldMatches = content.matchAll(/\*\*([^*]+)\*\*/g);
-    for (const match of boldMatches) {
-        const text = match[1].trim();
-        if (text.length > 3 &&
-            text.length < 60 &&
-            !text.includes("[") &&
-            !text.includes("{") &&
-            !text.includes('"')) {
-            concepts.add(text);
-        }
-    }
-    return Array.from(concepts).slice(0, 5);
-}
-/**
- * Build a synthesis answer from multiple source pages
- */
-function buildSynthesis(query, sourcePages, queryTerms) {
-    if (!sourcePages.length) {
-        return {
-            answer: `No information found related to: ${query}`,
-            concepts: [],
-        };
-    }
-    const allConcepts = new Set();
-    const sections = [];
-    // Add introduction
-    sections.push(`## Synthesis: ${query}\n`);
-    sections.push(`Based on ${sourcePages.length} source page(s):\n`);
-    // Add content from each source
-    for (const page of sourcePages) {
-        sections.push(`### ${page.title}`);
-        sections.push(`*Category: ${page.category} | Relevance: ${Math.round(page.relevance * 100)}%*\n`);
-        // Extract relevant sentences
-        const relevantSentences = extractRelevantSentences(page.content, queryTerms, 2);
-        if (relevantSentences.length > 0) {
-            sections.push(relevantSentences.map((s) => `- ${s.trim()}`).join("\n"));
-        }
-        else {
-            // Fallback: use first paragraph
-            const firstPara = page.content
-                .split("\n")
-                .filter((l) => l.trim() && !l.startsWith("#") && !l.startsWith("---"))
-                .slice(0, 1);
-            sections.push(firstPara.join("\n"));
-        }
-        // Collect concepts
-        const pageConcepts = extractKeyConcepts(page.content);
-        pageConcepts.forEach((c) => allConcepts.add(c));
-        sections.push("");
-    }
-    // Add summary
-    sections.push("\n## Key Concepts Found");
-    Array.from(allConcepts).forEach((c) => {
-        sections.push(`- ${c}`);
-    });
-    sections.push("\n## How to Extend This\n");
-    sections.push(`This synthesis was generated from ${sourcePages.length} page(s) containing the key terms: `);
-    sections.push(queryTerms.join(", "));
-    sections.push("\n\nAdd more source pages to deepen this synthesis.");
-    return {
-        answer: sections.join("\n"),
-        concepts: Array.from(allConcepts),
-    };
-}
-async function synthesizeAnswer(input) {
-    try {
-        const projectPath = node_path_1.default.resolve(input.project_path);
-        const docuDir = node_path_1.default.join(projectPath, ".docuflow");
-        const wikiDir = node_path_1.default.join(docuDir, "wiki");
-        // Load each source page
-        const sourcePages = [];
-        for (const pageId of input.source_page_ids) {
-            // Try to find the page (scan all category directories)
-            let found = false;
-            for (const categoryDir of ["entities", "concepts", "timelines", "syntheses"]) {
-                const filePath = node_path_1.default.join(wikiDir, categoryDir, `${pageId}.md`);
-                try {
-                    const read = await (0, filesystem_1.safeReadFile)(filePath);
-                    if (!read.error && !read.binary && read.content) {
-                        const titleMatch = read.content.match(/^#\s+(.+?)$/m);
-                        const title = titleMatch ? titleMatch[1].trim() : pageId;
-                        const category = categoryDir.replace("s", "");
-                        sourcePages.push({
-                            page_id: pageId,
-                            title,
-                            category,
-                            content: read.content,
-                            relevance: 1.0 - (sourcePages.length * 0.1), // Slight decay for order
-                        });
-                        found = true;
-                        break;
-                    }
-                }
-                catch (e) {
-                    // Try next category
-                }
-            }
-            if (!found && sourcePages.length === 0) {
-                // At least one page should be found
-                return {
-                    query: input.query,
-                    answer: `Could not find source page: ${pageId}`,
-                    source_pages: [],
-                    confidence: 0,
-                    key_concepts: [],
-                    error: `Page not found: ${pageId}`,
-                };
-            }
-        }
-        // Build query terms
-        const queryTerms = input.query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
-        // Generate synthesis
-        const { answer, concepts } = buildSynthesis(input.query, sourcePages, queryTerms);
-        // Calculate confidence based on number and relevance of sources
-        const confidence = Math.min(1.0, Math.max(0.3, sourcePages.length * 0.25));
-        return {
-            query: input.query,
-            answer,
-            source_pages: sourcePages.map((p) => ({
-                page_id: p.page_id,
-                title: p.title,
-                category: p.category,
-            })),
-            confidence,
-            key_concepts: concepts,
-        };
-    }
-    catch (e) {
-        return {
-            query: input.query,
-            answer: `Error synthesizing answer: ${e?.message ?? String(e)}`,
-            source_pages: [],
-            confidence: 0,
-            key_concepts: [],
-            error: e?.message ?? String(e),
-        };
-    }
-}