@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/chunks/chunk-TN4YZ3O7.js

@@ -0,0 +1,196 @@
+import {
+  getAllGrammars,
+  serializedToEBNF
+} from "./chunk-KMWCCOUJ.js";
+
+// src/context/index.ts
+import { readTopic, listTopics, getPackDocTopics } from "../docs/index.js";
+var PRESETS = {
+  core: ["orientation"],
+  authoring: [
+    "orientation",
+    "concepts",
+    "jsdoc-grammar",
+    "advanced-annotations",
+    "built-in-nodes",
+    "durable-gates",
+    "scaffold",
+    "node-conversion"
+  ],
+  ops: [
+    "orientation",
+    "library",
+    "cli-reference",
+    "mcp-tools",
+    "compilation",
+    "deployment",
+    "export-interface",
+    "debugging",
+    "error-codes"
+  ],
+  full: [
+    "orientation",
+    "concepts",
+    "tutorial",
+    "library",
+    "jsdoc-grammar",
+    "advanced-annotations",
+    "built-in-nodes",
+    "durable-gates",
+    "cancellation",
+    "cli-reference",
+    "mcp-tools",
+    "compilation",
+    "debugging",
+    "deployment",
+    "error-codes",
+    "export-interface",
+    "iterative-development",
+    "marketplace",
+    "node-conversion",
+    "scaffold"
+  ]
+};
+var PRESET_NAMES = Object.keys(PRESETS);
+var STANDALONE_PREAMBLE = `# Flow Weaver Reference
+
+Flow Weaver is a TypeScript workflow compiler. You write plain .ts files with
+JSDoc annotations (@flowWeaver nodeType, @flowWeaver workflow, @input, @output,
+@connect, @node, @scope). The compiler parses these annotations, validates the
+graph, and generates executable code inline. The source file is the workflow:
+no JSON configs, no YAML, no separate graph files.
+
+Key concepts: node types define reusable processing steps with typed input/output
+ports. Workflows instantiate nodes and connect their ports. Start and Exit are
+implicit boundary nodes. The compiler handles execution ordering, type checking,
+and code generation.`;
+var ASSISTANT_PREAMBLE = `# Flow Weaver Context
+
+You have the Flow Weaver MCP tools (fw_ prefix). This bundle is the map, not
+the reference. The list at the end names every topic it leaves out, with its
+size and how to load one.`;
+function resolveTopics(preset, explicit, add) {
+  const base = explicit ?? PRESETS[preset];
+  const packSlugs = getPackDocTopics().filter((t) => t.presets?.includes(preset)).map((t) => t.slug);
+  const combined = [...base, ...packSlugs, ...add ?? []];
+  return [...new Set(combined)];
+}
+function buildGrammarSection() {
+  const grammars = getAllGrammars();
+  const allProductions = [
+    ...grammars.port,
+    ...grammars.node,
+    ...grammars.connect,
+    ...grammars.scope
+  ];
+  const ebnf = serializedToEBNF(allProductions);
+  return `## JSDoc Annotation Grammar (EBNF)
+
+\`\`\`ebnf
+${ebnf}
+\`\`\``;
+}
+var NAVIGATION_HEADINGS = /^(related topics|next steps|see also)$/i;
+var HEADING_RE = /^(#{1,6})\s+(.*?)\s*$/;
+function prepareTopicBody(content) {
+  let lines = content.split("\n");
+  if (lines[0]?.startsWith("# ")) {
+    let startLine = 1;
+    if (lines.length > 1 && lines[1].trim() && !lines[1].startsWith("#")) {
+      startLine = 2;
+    }
+    lines = lines.slice(startLine);
+  }
+  while (lines.length > 0 && lines[0].trim() === "") lines.shift();
+  if (lines[0]?.match(/^#\s/)) {
+    lines.shift();
+    while (lines.length > 0 && lines[0].trim() === "") lines.shift();
+  }
+  const out = [];
+  let inCode = false;
+  let skipUntilLevel = 0;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCode = !inCode;
+      if (skipUntilLevel === 0) out.push(line);
+      continue;
+    }
+    if (inCode) {
+      if (skipUntilLevel === 0) out.push(line);
+      continue;
+    }
+    const heading = line.match(HEADING_RE);
+    if (heading) {
+      const level = heading[1].length;
+      if (skipUntilLevel > 0 && level <= skipUntilLevel) skipUntilLevel = 0;
+      if (skipUntilLevel === 0 && NAVIGATION_HEADINGS.test(heading[2])) {
+        skipUntilLevel = level;
+        continue;
+      }
+      if (skipUntilLevel === 0) out.push("#" + line);
+      continue;
+    }
+    if (skipUntilLevel === 0) out.push(line);
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function buildContext(options = {}) {
+  const profile = options.profile ?? "standalone";
+  const preset = options.preset ?? "core";
+  const includeGrammar = options.includeGrammar ?? true;
+  const topicSlugs = resolveTopics(preset, options.topics, options.addTopics);
+  const sections = [];
+  sections.push(profile === "standalone" ? STANDALONE_PREAMBLE : ASSISTANT_PREAMBLE);
+  if (includeGrammar) {
+    sections.push(buildGrammarSection());
+  }
+  let topicCount = 0;
+  const includedSlugs = [];
+  for (const slug of topicSlugs) {
+    const doc = readTopic(slug, true);
+    if (!doc) continue;
+    const heading = doc.name || slug;
+    sections.push(`## ${heading}
+
+${prepareTopicBody(doc.content)}`);
+    topicCount++;
+    includedSlugs.push(slug);
+  }
+  const included = new Set(includedSlugs);
+  const availableTopics = listTopics().filter((t) => !included.has(t.slug)).map((t) => ({
+    slug: t.slug,
+    description: t.description,
+    compactBytes: readTopic(t.slug, true)?.content.length ?? 0
+  })).sort((a, b) => a.slug.localeCompare(b.slug));
+  if (availableTopics.length > 0) {
+    const bundleText = sections.join("\n");
+    const rows = availableTopics.map((t) => {
+      const size = `${Math.max(1, Math.round(t.compactBytes / 1024))} KB`;
+      const mentioned = bundleText.includes(`\`${t.slug}\``);
+      return mentioned || !t.description ? `- \`${t.slug}\` (${size})` : `- \`${t.slug}\`: ${t.description} (${size})`;
+    });
+    const how = profile === "assistant" ? 'Read one with fw_docs(action="read", topic="<slug>", compact=true). Search first with fw_docs(action="search", query="...").' : 'Read one with `fw docs <slug> --compact`, or fw_docs(action="read", topic="<slug>", compact=true) once MCP tools are connected.';
+    sections.push(`## Other topics, load on demand
+
+${how}
+
+${rows.join("\n")}`);
+  }
+  const content = sections.join("\n\n---\n\n");
+  const lineCount = content.split("\n").length;
+  return {
+    content,
+    topicCount,
+    lineCount,
+    topicSlugs: includedSlugs,
+    profile,
+    availableTopics
+  };
+}
+
+export {
+  PRESETS,
+  PRESET_NAMES,
+  resolveTopics,
+  buildContext
+};

package/dist/chunks/chunk-TRMFB43C.js

@@ -0,0 +1,143 @@
+import {
+  require_picocolors
+} from "./chunk-HKZLQJDV.js";
+import {
+  __toESM
+} from "./chunk-SEWDMQ6Q.js";
+
+// src/cli/utils/logger.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var isTTY = process.stdout.isTTY === true;
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var humanToStderr = false;
+var print = (...args) => {
+  if (humanToStderr) console.error(...args);
+  else console.log(...args);
+};
+var logger = {
+  /** Send what the logger prints for a person to stderr (true) or back to stdout. */
+  toStderr(on) {
+    humanToStderr = on;
+  },
+  info(message) {
+    print(`${import_picocolors.default.blue("\u2139")} ${message}`);
+  },
+  success(message) {
+    print(`${import_picocolors.default.green("\u2713")} ${message}`);
+  },
+  error(message) {
+    console.error(`${import_picocolors.default.red("\u2717")} ${message}`);
+  },
+  warn(message) {
+    console.warn(import_picocolors.default.yellow(message));
+  },
+  debug(message) {
+    if (process.env.DEBUG) {
+      print(import_picocolors.default.dim(message));
+    }
+  },
+  log(message) {
+    print(message);
+  },
+  newline() {
+    print();
+  },
+  section(title) {
+    print();
+    print(`  ${import_picocolors.default.bold(title)}`);
+    print();
+  },
+  progress(current, total, item) {
+    print(`${import_picocolors.default.dim(`[${current}/${total}]`)} ${item}`);
+  },
+  // --- Formatting helpers ---
+  dim(message) {
+    return import_picocolors.default.dim(message);
+  },
+  bold(message) {
+    return import_picocolors.default.bold(message);
+  },
+  highlight(value) {
+    return import_picocolors.default.cyan(value);
+  },
+  // --- Branded output ---
+  banner(version) {
+    print(`  ${import_picocolors.default.bold(import_picocolors.default.cyan("flow-weaver"))} ${import_picocolors.default.dim(`v${version}`)}`);
+  },
+  // --- Table output ---
+  table(rows) {
+    if (rows.length === 0) return;
+    const col0 = Math.max(...rows.map((r) => r[0].length)) + 2;
+    const col1 = Math.max(...rows.map((r) => r[1].length)) + 2;
+    for (const [label, value, status] of rows) {
+      const line = `  ${label.padEnd(col0)}${value.padEnd(col1)}${status ?? ""}`;
+      print(line);
+    }
+  },
+  // --- Spinner ---
+  spinner(message) {
+    if (!isTTY) {
+      process.stderr.write(`  ${message}
+`);
+      return {
+        stop(msg) {
+          if (msg) process.stderr.write(`  ${import_picocolors.default.green("\u2713")} ${msg}
+`);
+        },
+        fail(msg) {
+          if (msg) process.stderr.write(`  ${import_picocolors.default.red("\u2717")} ${msg}
+`);
+        },
+        update() {
+        }
+      };
+    }
+    let frame = 0;
+    let text = message;
+    const interval = setInterval(() => {
+      const spinner = import_picocolors.default.cyan(SPINNER_FRAMES[frame % SPINNER_FRAMES.length]);
+      process.stderr.write(`\r\x1B[K  ${spinner} ${text}`);
+      frame++;
+    }, 80);
+    const clear = () => {
+      clearInterval(interval);
+      process.stderr.write("\r\x1B[K");
+    };
+    return {
+      stop(msg) {
+        clear();
+        if (msg) process.stderr.write(`  ${import_picocolors.default.green("\u2713")} ${msg}
+`);
+      },
+      fail(msg) {
+        clear();
+        if (msg) process.stderr.write(`  ${import_picocolors.default.red("\u2717")} ${msg}
+`);
+      },
+      update(msg) {
+        text = msg;
+      }
+    };
+  },
+  // --- Timer ---
+  timer() {
+    const start = performance.now();
+    return {
+      elapsed() {
+        const ms = performance.now() - start;
+        if (ms < 1e3) return `${Math.round(ms)}ms`;
+        if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+        const mins = Math.floor(ms / 6e4);
+        const secs = Math.round(ms % 6e4 / 1e3);
+        return `${mins}m ${secs}s`;
+      },
+      ms() {
+        return Math.round(performance.now() - start);
+      }
+    };
+  }
+};
+
+export {
+  logger
+};