@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-YSPBPZDV.js

@@ -0,0 +1,148 @@
+// src/api/workflow-file-operations.ts
+import * as ts from "typescript";
+var RUNTIME_END_MARKER = "// @flow-weaver-runtime-end";
+function findWorkflowFunctions(source) {
+  const sourceFile = ts.createSourceFile(
+    "temp.ts",
+    source,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const workflows = [];
+  ts.forEachChild(sourceFile, (node) => {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      const functionName = node.name.text;
+      const functionStart = node.getFullStart();
+      const leadingComments = ts.getLeadingCommentRanges(source, functionStart);
+      if (!leadingComments) return;
+      for (const comment of leadingComments) {
+        if (comment.kind === ts.SyntaxKind.MultiLineCommentTrivia) {
+          const commentText = source.slice(comment.pos, comment.end);
+          if (commentText.includes("@flowWeaver workflow")) {
+            const nameMatch = commentText.match(/@name\s+(\S+)/);
+            const name = nameMatch ? nameMatch[1] : functionName;
+            const isExported = node.modifiers?.some(
+              (m) => m.kind === ts.SyntaxKind.ExportKeyword
+            ) ?? false;
+            workflows.push({
+              node,
+              name,
+              functionName,
+              isExported,
+              jsdocStart: comment.pos,
+              jsdocEnd: comment.end
+            });
+            break;
+          }
+        }
+      }
+    }
+  });
+  return workflows;
+}
+function generateWorkflowScaffold(workflowName, exported) {
+  const exportKeyword = exported ? "export " : "";
+  return `/**
+ * @flowWeaver workflow
+ */
+${exportKeyword}function ${workflowName}(execute: boolean, data: {}): { onSuccess: boolean; onFailure: boolean } {
+  throw new Error("Not implemented");
+}`;
+}
+function addWorkflowToSource(source, workflowName, options = {}) {
+  const { exported = true } = options;
+  const existingWorkflows = findWorkflowFunctions(source);
+  const exists = existingWorkflows.some(
+    (w) => w.name === workflowName || w.functionName === workflowName
+  );
+  if (exists) {
+    throw new Error(`Workflow "${workflowName}" already exists`);
+  }
+  const newWorkflow = generateWorkflowScaffold(workflowName, exported);
+  let insertPosition;
+  const runtimeEndPos = source.indexOf(RUNTIME_END_MARKER);
+  if (runtimeEndPos !== -1) {
+    const afterMarker = source.indexOf("\n", runtimeEndPos);
+    insertPosition = afterMarker !== -1 ? afterMarker + 1 : runtimeEndPos + RUNTIME_END_MARKER.length;
+  } else if (existingWorkflows.length > 0) {
+    insertPosition = existingWorkflows[0].jsdocStart;
+  } else {
+    insertPosition = source.length;
+  }
+  const before = source.slice(0, insertPosition);
+  const after = source.slice(insertPosition);
+  const needsLeadingNewline = before.length > 0 && !before.endsWith("\n\n");
+  const needsTrailingNewline = after.length > 0 && !after.startsWith("\n");
+  return before + (needsLeadingNewline ? "\n\n" : "") + newWorkflow + (needsTrailingNewline ? "\n\n" : "") + after;
+}
+function removeWorkflowFromSource(source, workflowName) {
+  const workflows = findWorkflowFunctions(source);
+  const workflowToRemove = workflows.find(
+    (w) => w.name === workflowName || w.functionName === workflowName
+  );
+  if (!workflowToRemove) {
+    throw new Error(`Workflow "${workflowName}" not found`);
+  }
+  if (workflows.length === 1) {
+    throw new Error(`Cannot remove the last workflow from file`);
+  }
+  const startPos = workflowToRemove.jsdocStart;
+  let endPos = workflowToRemove.node.end;
+  while (endPos < source.length && (source[endPos] === "\n" || source[endPos] === "\r")) {
+    endPos++;
+  }
+  const before = source.slice(0, startPos);
+  const after = source.slice(endPos);
+  return before + after;
+}
+function toggleWorkflowExport(source, workflowName) {
+  const workflows = findWorkflowFunctions(source);
+  const workflow = workflows.find(
+    (w) => w.name === workflowName || w.functionName === workflowName
+  );
+  if (!workflow) {
+    throw new Error(`Workflow "${workflowName}" not found`);
+  }
+  let functionKeywordPos = -1;
+  for (let i = workflow.jsdocEnd; i < source.length - 7; i++) {
+    if (source.slice(i, i + 8) === "function") {
+      functionKeywordPos = i;
+      break;
+    }
+    if (source.slice(i, i + 15) === "export function") {
+      functionKeywordPos = i;
+      break;
+    }
+  }
+  if (functionKeywordPos === -1) {
+    throw new Error(`Could not find function declaration for "${workflowName}"`);
+  }
+  if (workflow.isExported) {
+    const exportPos = source.lastIndexOf("export", functionKeywordPos);
+    if (exportPos !== -1 && exportPos >= workflow.jsdocEnd) {
+      let spaceEnd = exportPos + 6;
+      while (spaceEnd < source.length && (source[spaceEnd] === " " || source[spaceEnd] === "	")) {
+        spaceEnd++;
+      }
+      return source.slice(0, exportPos) + source.slice(spaceEnd);
+    }
+  } else {
+    return source.slice(0, functionKeywordPos) + "export " + source.slice(functionKeywordPos);
+  }
+  return source;
+}
+function getAvailableWorkflows(source) {
+  const workflows = findWorkflowFunctions(source);
+  return workflows.map((w) => ({
+    name: w.name,
+    functionName: w.functionName,
+    isExported: w.isExported
+  }));
+}
+
+export {
+  addWorkflowToSource,
+  removeWorkflowFromSource,
+  toggleWorkflowExport,
+  getAvailableWorkflows
+};

package/dist/chunks/chunk-ZKEGXO73.js

@@ -0,0 +1,282 @@
+import {
+  Ze
+} from "./chunk-REEYC73I.js";
+import {
+  getErrorMessage
+} from "./chunk-DUO6H5PR.js";
+
+// src/marketplace/registry.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/marketplace/npmrc.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var PUBLIC_REGISTRY = "https://registry.npmjs.org/";
+function parseNpmrc(text, env = process.env) {
+  const out = /* @__PURE__ */ new Map();
+  if (typeof text !== "string") return out;
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
+    let missing = false;
+    value = value.replace(/\$\{([^}]+)\}/g, (_, name) => {
+      const v = env[name];
+      if (v === void 0) missing = true;
+      return v ?? "";
+    });
+    if (missing) continue;
+    out.set(key, value);
+  }
+  return out;
+}
+function nerfDart(url) {
+  const u = new URL(url);
+  const p = u.pathname.endsWith("/") ? u.pathname : `${u.pathname}/`;
+  return `//${u.host}${p}`;
+}
+var withSlash = (u) => u.endsWith("/") ? u : `${u}/`;
+function readNpmConfig(projectDir, env = process.env, home = os.homedir()) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const file of [path.join(home, ".npmrc"), path.join(projectDir, ".npmrc")]) {
+    let text;
+    try {
+      text = fs.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const [k, v] of parseNpmrc(text, env)) merged.set(k, v);
+  }
+  const envRegistry = env.npm_config_registry ?? env.NPM_CONFIG_REGISTRY;
+  if (envRegistry) merged.set("registry", envRegistry);
+  return merged;
+}
+function authorizationFor(url, config) {
+  const dart = nerfDart(url);
+  let best;
+  for (const [key, value] of config) {
+    const m = key.match(/^(\/\/.+\/):(_authToken|_auth|_password)$/);
+    if (!m || !dart.startsWith(m[1]) || !value) continue;
+    if (best && m[1].length <= best.len) continue;
+    if (m[2] === "_authToken") best = { len: m[1].length, value: `Bearer ${value}` };
+    else if (m[2] === "_auth") best = { len: m[1].length, value: `Basic ${value}` };
+    else {
+      const user = config.get(`${m[1]}:username`);
+      if (user) best = { len: m[1].length, value: `Basic ${Buffer.from(`${user}:${value}`).toString("base64")}` };
+    }
+  }
+  return best?.value;
+}
+function resolveRegistries(projectDir, config = readNpmConfig(projectDir)) {
+  const byUrl = /* @__PURE__ */ new Map();
+  const defaultUrl = withSlash(config.get("registry") || PUBLIC_REGISTRY);
+  byUrl.set(defaultUrl, { url: defaultUrl, scopes: [], isDefault: true });
+  for (const [key, value] of config) {
+    const m = key.match(/^(@[^:]+):registry$/);
+    if (!m || !value) continue;
+    const url = withSlash(value);
+    const r = byUrl.get(url) ?? { url, scopes: [], isDefault: false };
+    r.scopes.push(m[1]);
+    byUrl.set(url, r);
+  }
+  for (const r of byUrl.values()) {
+    const authorization = authorizationFor(r.url, config);
+    if (authorization) r.authorization = authorization;
+  }
+  return [...byUrl.values()];
+}
+
+// src/marketplace/registry.ts
+var MARKETPLACE_KEYWORD = "flow-weaver-marketplace-pack";
+var NPM_SEARCH_URL = "https://registry.npmjs.org/-/v1/search";
+var PACK_NAME_RE = /^(@[^/]+\/)?flow-weaver-pack-.+$/;
+function isPackResult(pkg) {
+  return (pkg.keywords ?? []).includes(MARKETPLACE_KEYWORD) || PACK_NAME_RE.test(pkg.name);
+}
+async function searchOne(searchUrl, query, limit, publicSyntax, authorization) {
+  const url = new URL(searchUrl);
+  const text = publicSyntax ? [`keywords:${MARKETPLACE_KEYWORD}`, ...query ? [query] : []].join(" ") : query || "flow-weaver";
+  url.searchParams.set("text", text);
+  url.searchParams.set("size", String(limit));
+  const response = await fetch(url.toString(), authorization ? { headers: { Authorization: authorization } } : void 0);
+  if (!response.ok) {
+    throw new Error(`npm search failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return (data.objects ?? []).filter((obj) => isPackResult(obj.package)).map((obj) => ({
+    name: obj.package.name,
+    version: obj.package.version,
+    description: obj.package.description,
+    keywords: obj.package.keywords,
+    publisher: obj.package.publisher?.username,
+    official: obj.package.name.startsWith("@synergenius/")
+  }));
+}
+async function searchPackages(options = {}) {
+  const { query, limit = 20, registryUrl } = options;
+  const searchUrl = registryUrl ?? NPM_SEARCH_URL;
+  const isPublic = searchUrl.startsWith(PUBLIC_REGISTRY);
+  let authorization;
+  if (registryUrl) {
+    try {
+      authorization = resolveRegistries(process.cwd()).find((r) => searchUrl.startsWith(r.url))?.authorization;
+    } catch {
+      authorization = void 0;
+    }
+  }
+  return searchOne(searchUrl, query, limit, isPublic, authorization);
+}
+async function searchAllRegistries(options = {}) {
+  const { query, limit = 20 } = options;
+  const registries = options.registries ?? resolveRegistries(options.projectDir ?? process.cwd());
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const searched = [];
+  await Promise.all(registries.map(async (r) => {
+    const entry = { url: r.url, scopes: r.scopes, authenticated: !!r.authorization, ok: false, count: 0 };
+    try {
+      const found = await searchOne(`${r.url}-/v1/search`, query, limit, r.url === PUBLIC_REGISTRY, r.authorization);
+      entry.ok = true;
+      entry.count = found.length;
+      for (const pkg of found) {
+        if (seen.has(pkg.name)) continue;
+        seen.add(pkg.name);
+        results.push({ ...pkg, registry: new URL(r.url).host });
+      }
+    } catch (err) {
+      entry.error = getErrorMessage(err);
+    }
+    searched.push(entry);
+  }));
+  searched.sort((a, b) => registries.findIndex((r) => r.url === a.url) - registries.findIndex((r) => r.url === b.url));
+  return { results, searched };
+}
+async function listInstalledPackages(projectDir) {
+  const nodeModules = path2.join(projectDir, "node_modules");
+  if (!fs2.existsSync(nodeModules)) return [];
+  const patterns = [
+    path2.join(nodeModules, "*", "flowweaver.manifest.json"),
+    path2.join(nodeModules, "@*", "*", "flowweaver.manifest.json")
+  ];
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const manifestPaths = await Ze(pattern.replace(/\\/g, "/"), { absolute: true });
+    for (const manifestPath of manifestPaths) {
+      try {
+        const pkgDir = path2.dirname(manifestPath);
+        const manifest = JSON.parse(
+          fs2.readFileSync(manifestPath, "utf-8")
+        );
+        if (seen.has(manifest.name)) continue;
+        seen.add(manifest.name);
+        const pkgJsonPath = path2.join(pkgDir, "package.json");
+        let version = manifest.version;
+        if (fs2.existsSync(pkgJsonPath)) {
+          const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+          version = pkg.version ?? manifest.version;
+        }
+        results.push({
+          name: manifest.name,
+          version,
+          manifest,
+          path: pkgDir
+        });
+      } catch {
+      }
+    }
+  }
+  return results;
+}
+function getInstalledPackageManifest(projectDir, packageName) {
+  const packageDir = path2.join(projectDir, "node_modules", packageName);
+  const manifestPath = path2.join(packageDir, "flowweaver.manifest.json");
+  if (!fs2.existsSync(manifestPath)) return null;
+  try {
+    return JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function discoverTagHandlers(projectDir) {
+  const packages = await listInstalledPackages(projectDir);
+  const handlers = [];
+  for (const pkg of packages) {
+    const manifest = pkg.manifest;
+    if (!manifest.tagHandlers) continue;
+    for (const handler of manifest.tagHandlers) {
+      handlers.push({
+        ...handler,
+        absoluteFile: path2.join(pkg.path, handler.file),
+        packageName: pkg.name
+      });
+    }
+  }
+  return handlers;
+}
+async function discoverValidationRuleSets(projectDir) {
+  const packages = await listInstalledPackages(projectDir);
+  const ruleSets = [];
+  for (const pkg of packages) {
+    const manifest = pkg.manifest;
+    if (!manifest.validationRuleSets) continue;
+    for (const ruleSet of manifest.validationRuleSets) {
+      ruleSets.push({
+        ...ruleSet,
+        absoluteFile: path2.join(pkg.path, ruleSet.file),
+        packageName: pkg.name
+      });
+    }
+  }
+  return ruleSets;
+}
+async function discoverDocTopics(projectDir) {
+  const packages = await listInstalledPackages(projectDir);
+  const topics = [];
+  for (const pkg of packages) {
+    const manifest = pkg.manifest;
+    if (!manifest.docs) continue;
+    for (const doc of manifest.docs) {
+      topics.push({
+        ...doc,
+        absoluteFile: path2.join(pkg.path, doc.file),
+        packageName: pkg.name
+      });
+    }
+  }
+  return topics;
+}
+async function discoverInitContributions(projectDir) {
+  const packages = await listInstalledPackages(projectDir);
+  const contributions = [];
+  for (const pkg of packages) {
+    const manifest = pkg.manifest;
+    if (!manifest.initContributions) continue;
+    contributions.push({
+      ...manifest.initContributions,
+      packageName: pkg.name
+    });
+  }
+  return contributions;
+}
+
+export {
+  PUBLIC_REGISTRY,
+  parseNpmrc,
+  nerfDart,
+  readNpmConfig,
+  resolveRegistries,
+  searchPackages,
+  searchAllRegistries,
+  listInstalledPackages,
+  getInstalledPackageManifest,
+  discoverTagHandlers,
+  discoverValidationRuleSets,
+  discoverDocTopics,
+  discoverInitContributions
+};