@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-VXWNLYQU.mjs

@@ -0,0 +1,9 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+
+// src/generated-version.ts
+var VERSION = "0.44.0";
+
+export {
+  VERSION
+};

package/dist/cli/flow-weaver-chunk-W3YNK26P.mjs

@@ -0,0 +1,149 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  AnnotationParser,
+  parser
+} from "./flow-weaver-chunk-APX6MQ5A.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+
+// src/api/parse.ts
+import { Project } from "ts-morph";
+import ts from "typescript";
+var MULTIPLE_WORKFLOWS_MARKER = "[MULTIPLE_WORKFLOWS_FOUND]";
+function isMultipleWorkflows(errors) {
+  return errors.length > 0 && errors.every((e) => typeof e === "string" && e.startsWith(MULTIPLE_WORKFLOWS_MARKER));
+}
+async function parseWorkflow(filePath, options) {
+  const errors = [];
+  const warnings = [];
+  let availableWorkflows = [];
+  try {
+    if (options?.projectDir) {
+      await parser.loadPackHandlers(options.projectDir);
+    }
+    const parsed = parser.parse(filePath, options?.externalNodeTypes);
+    warnings.push(...parsed.warnings);
+    errors.push(...parsed.errors);
+    availableWorkflows = parsed.workflows.map((w) => w.functionName);
+    let workflowName = options?.workflowName;
+    if (!workflowName) {
+      if (parsed.workflows.length === 0) {
+        if (options?.nodeTypesOnly && parsed.nodeTypes.length > 0) {
+          return {
+            ast: {
+              type: "Workflow",
+              functionName: "",
+              name: "",
+              sourceFile: filePath,
+              nodeTypes: parsed.nodeTypes,
+              instances: [],
+              connections: [],
+              scopes: {},
+              startPorts: {},
+              exitPorts: {},
+              imports: []
+            },
+            errors: [],
+            warnings,
+            availableWorkflows: [],
+            allWorkflows: []
+          };
+        }
+        const nodeTypeCount = parsed.nodeTypes.length;
+        const nodeTypeHint = nodeTypeCount > 0 ? ` (found ${nodeTypeCount} node type${nodeTypeCount === 1 ? "" : "s"}, but no workflow function)` : "";
+        errors.push(
+          `No workflows found in file${nodeTypeHint}. Add a /** @flowWeaver workflow */ annotation above an exported function to define a workflow. Ensure node type functions are annotated with /** @flowWeaver nodeType */ first.`
+        );
+        throw new Error("No workflows found in file");
+      }
+      if (parsed.workflows.length > 1) {
+        errors.push(
+          `${MULTIPLE_WORKFLOWS_MARKER} Multiple workflows found: ${availableWorkflows.join(", ")}. Please specify workflowName in options.`
+        );
+        throw new Error("Multiple workflows found, workflowName required");
+      }
+      workflowName = parsed.workflows[0].functionName;
+    }
+    const workflow = parsed.workflows.find((w) => w.functionName === workflowName);
+    if (!workflow) {
+      errors.push(
+        `Workflow "${workflowName}" not found. Available: ${availableWorkflows.join(", ")}`
+      );
+      throw new Error(`Workflow "${workflowName}" not found`);
+    }
+    return {
+      ast: workflow,
+      errors,
+      warnings,
+      availableWorkflows,
+      allWorkflows: parsed.workflows
+    };
+  } catch (error) {
+    if (errors.length > 0) {
+      return {
+        ast: {},
+        // Return empty AST on error
+        errors,
+        warnings,
+        availableWorkflows,
+        // Include available workflows even on error
+        allWorkflows: []
+      };
+    }
+    const errorMessage = getErrorMessage(error);
+    errors.push(`Failed to parse workflow: ${errorMessage}`);
+    return {
+      ast: {},
+      errors,
+      warnings,
+      availableWorkflows,
+      allWorkflows: []
+    };
+  }
+}
+async function parseWorkflowSourceAtPath(filePath, source, options) {
+  const sourceParser = options?.sourceOverrideLoader === void 0 ? parser : new AnnotationParser(new Project({
+    skipFileDependencyResolution: false,
+    compilerOptions: {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.NodeNext,
+      moduleResolution: ts.ModuleResolutionKind.NodeNext,
+      allowImportingTsExtensions: true,
+      allowJs: true,
+      skipLibCheck: true,
+      types: []
+    }
+  }));
+  const parsed = sourceParser.parseSourceAtPath(
+    filePath,
+    source,
+    options?.externalNodeTypes,
+    options?.sourceImportResolver,
+    options?.sourceOverrideLoader
+  );
+  const errors = [...parsed.errors];
+  const warnings = [...parsed.warnings];
+  const availableWorkflows = parsed.workflows.map((workflow) => workflow.functionName);
+  const workflowName = options?.workflowName;
+  const ast = workflowName === void 0 ? parsed.workflows.length === 1 ? parsed.workflows[0] : void 0 : parsed.workflows.find((workflow) => workflow.functionName === workflowName);
+  if (ast === void 0) {
+    errors.push(workflowName === void 0 ? "A source override must contain exactly one workflow or name it explicitly" : `Workflow '${workflowName}' not found`);
+    throw new Error(errors.join("\n"));
+  }
+  return {
+    ast,
+    errors,
+    warnings,
+    availableWorkflows,
+    allWorkflows: parsed.workflows
+  };
+}
+
+export {
+  MULTIPLE_WORKFLOWS_MARKER,
+  isMultipleWorkflows,
+  parseWorkflow,
+  parseWorkflowSourceAtPath
+};

package/dist/cli/flow-weaver-chunk-XG2WKXYZ.mjs

@@ -0,0 +1,324 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+
+// src/docs/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+function getDocsDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const packageRoot = path.resolve(path.dirname(thisFile), "..", "..");
+  return path.join(packageRoot, "docs", "reference");
+}
+function parseFrontmatter(raw) {
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) {
+    return {
+      frontmatter: { name: "", description: "", keywords: [] },
+      body: raw
+    };
+  }
+  const fmBlock = fmMatch[1];
+  const body = fmMatch[2];
+  let name = "";
+  let description = "";
+  let keywords = [];
+  for (const line of fmBlock.split("\n")) {
+    const nameMatch = line.match(/^name:\s*(.+)$/);
+    if (nameMatch) {
+      name = nameMatch[1].trim();
+      continue;
+    }
+    const descMatch = line.match(/^description:\s*(.+)$/);
+    if (descMatch) {
+      description = descMatch[1].trim();
+      continue;
+    }
+    const kwMatch = line.match(/^keywords:\s*\[(.+)\]$/);
+    if (kwMatch) {
+      keywords = kwMatch[1].split(",").map((k) => k.trim().replace(/^['"]|['"]$/g, ""));
+      continue;
+    }
+  }
+  return { frontmatter: { name, description, keywords }, body };
+}
+function splitSections(body) {
+  const lines = body.split("\n");
+  const sections = [];
+  let currentHeading = "";
+  let currentLevel = 0;
+  let currentLines = [];
+  function flush() {
+    if (currentHeading || currentLines.length > 0) {
+      const content = currentLines.join("\n").trim();
+      const codeBlocks = [];
+      const codeRe = /```[\s\S]*?```/g;
+      let m;
+      while ((m = codeRe.exec(content)) !== null) {
+        codeBlocks.push(m[0]);
+      }
+      sections.push({
+        heading: currentHeading,
+        level: currentLevel,
+        content,
+        codeBlocks
+      });
+    }
+  }
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      flush();
+      currentLevel = headingMatch[1].length;
+      currentHeading = headingMatch[2];
+      currentLines = [];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
+function listTopics() {
+  const docsDir = getDocsDir();
+  const coreTopics = [];
+  if (fs.existsSync(docsDir)) {
+    const files = fs.readdirSync(docsDir).filter((f) => f.endsWith(".md")).sort();
+    for (const file of files) {
+      const raw = fs.readFileSync(path.join(docsDir, file), "utf-8");
+      const { frontmatter } = parseFrontmatter(raw);
+      coreTopics.push({
+        slug: file.replace(/\.md$/, ""),
+        name: frontmatter.name,
+        description: frontmatter.description,
+        keywords: frontmatter.keywords
+      });
+    }
+  }
+  const coreSlugs = new Set(coreTopics.map((t) => t.slug));
+  for (const packTopic of packDocTopics) {
+    if (!coreSlugs.has(packTopic.slug)) {
+      coreTopics.push({
+        slug: packTopic.slug,
+        name: packTopic.name,
+        description: packTopic.description,
+        keywords: packTopic.keywords
+      });
+    }
+  }
+  return coreTopics;
+}
+function readTopic(slug, compact) {
+  const docsDir = getDocsDir();
+  const coreFilePath = path.join(docsDir, `${slug}.md`);
+  if (fs.existsSync(coreFilePath)) {
+    const raw = fs.readFileSync(coreFilePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(raw);
+    const content = compact ? buildCompactContent(frontmatter, body) : body.trim();
+    return {
+      slug,
+      name: frontmatter.name,
+      description: frontmatter.description,
+      keywords: frontmatter.keywords,
+      content
+    };
+  }
+  const packTopic = packDocTopics.find((t) => t.slug === slug);
+  if (packTopic && fs.existsSync(packTopic.filePath)) {
+    const raw = fs.readFileSync(packTopic.filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(raw);
+    const content = compact ? buildCompactContent(
+      { name: frontmatter.name || packTopic.name, description: frontmatter.description || packTopic.description, keywords: frontmatter.keywords.length > 0 ? frontmatter.keywords : packTopic.keywords },
+      body
+    ) : body.trim();
+    return {
+      slug,
+      name: frontmatter.name || packTopic.name,
+      description: frontmatter.description || packTopic.description,
+      keywords: frontmatter.keywords.length > 0 ? frontmatter.keywords : packTopic.keywords,
+      content
+    };
+  }
+  return null;
+}
+function readTopicStructured(slug) {
+  const docsDir = getDocsDir();
+  const filePath = path.join(docsDir, `${slug}.md`);
+  if (!fs.existsSync(filePath)) return null;
+  const raw = fs.readFileSync(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(raw);
+  const sections = splitSections(body);
+  return {
+    slug,
+    name: frontmatter.name,
+    description: frontmatter.description,
+    keywords: frontmatter.keywords,
+    sections
+  };
+}
+var STOP_WORDS = /* @__PURE__ */ new Set(["a", "an", "the", "as", "to", "of", "in", "on", "for", "and", "or", "with", "how", "do", "i", "my", "is", "it", "be", "can", "from", "that", "this", "add", "use", "using"]);
+function searchDocs(query) {
+  const topics = listTopics();
+  const docsDir = getDocsDir();
+  const queryLower = query.toLowerCase().trim();
+  const allTerms = queryLower.split(/\s+/).filter(Boolean);
+  const meaningful = allTerms.filter((t) => !STOP_WORDS.has(t));
+  const queryTerms = meaningful.length ? meaningful : allTerms;
+  const needed = Math.max(1, Math.ceil(queryTerms.length / 2));
+  const results = [];
+  for (const topic of topics) {
+    const keywordMatch = topic.keywords.some(
+      (kw) => queryTerms.some((term) => kw.toLowerCase().includes(term))
+    );
+    const packTopic = packDocTopics.find((p) => p.slug === topic.slug);
+    const filePath = packTopic ? packTopic.filePath : path.join(docsDir, `${topic.slug}.md`);
+    if (!fs.existsSync(filePath)) continue;
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const { body } = parseFrontmatter(raw);
+    const sections = splitSections(body);
+    for (const section of sections) {
+      const sectionLower = section.content.toLowerCase();
+      const headingLower = section.heading.toLowerCase();
+      let relevance = 0;
+      const topicLower = `${topic.name} ${topic.slug}`.toLowerCase();
+      if (sectionLower.includes(queryLower)) {
+        relevance += 10;
+      }
+      let matched = 0;
+      for (const term of queryTerms) {
+        const inHeading = headingLower.includes(term);
+        const inBody = sectionLower.includes(term);
+        if (inHeading) relevance += 6;
+        if (inBody) relevance += 2;
+        if (topicLower.includes(term)) relevance += 2;
+        if (inHeading || inBody) matched++;
+      }
+      if (keywordMatch) relevance += 3;
+      if (matched < needed) relevance = 0;
+      else if (queryTerms.length > 1) relevance = Math.round(relevance * (0.5 + matched / (2 * queryTerms.length)));
+      if (relevance > 0) {
+        const lines = section.content.split("\n");
+        const matchingLines = [];
+        for (const line of lines) {
+          if (queryTerms.some((term) => line.toLowerCase().includes(term))) {
+            matchingLines.push(collapseTableRow(line).trim());
+            if (matchingLines.length >= 3) break;
+          }
+        }
+        results.push({
+          topic: topic.name,
+          slug: topic.slug,
+          section: section.heading,
+          heading: section.heading,
+          excerpt: matchingLines.join("\n") || section.content.slice(0, 200),
+          relevance
+        });
+      }
+    }
+  }
+  results.sort((a, b) => b.relevance - a.relevance);
+  return results;
+}
+var packDocTopics = [];
+function registerPackDocTopics(topics) {
+  for (const t of topics) {
+    if (packDocTopics.some((p) => p.slug === t.slug)) continue;
+    packDocTopics.push({
+      slug: t.slug,
+      name: t.name,
+      description: t.description ?? "",
+      keywords: t.keywords ?? [],
+      presets: t.presets ?? [],
+      filePath: t.absoluteFile
+    });
+  }
+}
+function getPackDocTopics() {
+  return packDocTopics;
+}
+function collapseTableRow(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("|")) return line;
+  if (/^[|\s:-]+$/.test(trimmed)) return trimmed.replace(/-{4,}/g, "---").replace(/ {2,}/g, " ");
+  return trimmed.replace(/ {2,}/g, " ");
+}
+var LIST_ITEM_RE = /^\s*(?:[-*]\s|\d+\.\s|>\s?)/;
+function buildCompactContent(frontmatter, body) {
+  const lines = body.split("\n");
+  const output = [];
+  output.push(`# ${frontmatter.name}`);
+  output.push(frontmatter.description);
+  output.push("");
+  let inCodeBlock = false;
+  let inListItem = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      inListItem = false;
+      output.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      output.push(line);
+      continue;
+    }
+    if (line.trim() === "") {
+      inListItem = false;
+      continue;
+    }
+    if (line.match(/^#{1,6}\s/)) {
+      inListItem = false;
+      output.push("");
+      output.push(line);
+      continue;
+    }
+    if (line.trim().startsWith("|")) {
+      inListItem = false;
+      output.push(collapseTableRow(line));
+      continue;
+    }
+    if (LIST_ITEM_RE.test(line)) {
+      inListItem = true;
+      output.push(line);
+      continue;
+    }
+    if (inListItem && /^\s{2,}\S/.test(line)) {
+      output.push(line);
+      continue;
+    }
+    inListItem = false;
+  }
+  return dropEmptyHeadings(output).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function dropEmptyHeadings(lines) {
+  const headingLevel = [];
+  let inCode = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCode = !inCode;
+      headingLevel.push(null);
+      continue;
+    }
+    const m = !inCode ? line.match(/^(#{1,6})\s/) : null;
+    headingLevel.push(m ? m[1].length : null);
+  }
+  const keep = lines.map(() => true);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const level = headingLevel[i];
+    if (level === null) continue;
+    let j = i + 1;
+    while (j < lines.length && (!keep[j] || lines[j].trim() === "")) j++;
+    const next = j < lines.length ? headingLevel[j] : null;
+    if (j >= lines.length || next !== null && next <= level) keep[i] = false;
+  }
+  return lines.filter((_, i) => keep[i]);
+}
+
+export {
+  listTopics,
+  readTopic,
+  readTopicStructured,
+  searchDocs,
+  registerPackDocTopics,
+  getPackDocTopics
+};