@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-init-personas-NOGZTQQ2.mjs

@@ -0,0 +1,48 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  AGENT_CONTEXT_PRESETS,
+  AGENT_LAUNCH_DEFAULTS,
+  FILE_DESCRIPTIONS,
+  PERSONA_CHOICES,
+  PERSONA_CONFIRMATIONS,
+  USE_CASE_CHOICES,
+  USE_CASE_TEMPLATES,
+  extractWorkflowPreview,
+  generateAgentPrompt,
+  generateEditorPrompt,
+  generateExampleWorkflow,
+  generateReadme,
+  generateSetupPromptFile,
+  getTemplateSubChoices,
+  printCopyablePrompt,
+  printNextSteps,
+  registerPackUseCase,
+  selectTemplateForPersona
+} from "./flow-weaver-chunk-T7X5A23H.mjs";
+import "./flow-weaver-chunk-MMV2XGD3.mjs";
+import "./flow-weaver-chunk-MKAFQWLP.mjs";
+import "./flow-weaver-chunk-XG2WKXYZ.mjs";
+import "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+export {
+  AGENT_CONTEXT_PRESETS,
+  AGENT_LAUNCH_DEFAULTS,
+  FILE_DESCRIPTIONS,
+  PERSONA_CHOICES,
+  PERSONA_CONFIRMATIONS,
+  USE_CASE_CHOICES,
+  USE_CASE_TEMPLATES,
+  extractWorkflowPreview,
+  generateAgentPrompt,
+  generateEditorPrompt,
+  generateExampleWorkflow,
+  generateReadme,
+  generateSetupPromptFile,
+  getTemplateSubChoices,
+  printCopyablePrompt,
+  printNextSteps,
+  registerPackUseCase,
+  selectTemplateForPersona
+};

package/dist/cli/flow-weaver-manifest-4JNUSEB3.mjs

@@ -0,0 +1,18 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  generateManifest,
+  readManifest,
+  writeManifest
+} from "./flow-weaver-chunk-AA3NATMX.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+export {
+  generateManifest,
+  readManifest,
+  writeManifest
+};

package/dist/cli/flow-weaver-market-WA4CKHKV.mjs

@@ -0,0 +1,444 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import "./flow-weaver-chunk-TLV3VZUN.mjs";
+import {
+  npmInstall,
+  runNpm
+} from "./flow-weaver-chunk-3ZLMPQTH.mjs";
+import {
+  generateManifest,
+  readManifest,
+  writeManifest
+} from "./flow-weaver-chunk-AA3NATMX.mjs";
+import {
+  validatePackage
+} from "./flow-weaver-chunk-2C7PZCV5.mjs";
+import {
+  listInstalledPackages,
+  searchAllRegistries,
+  searchPackages
+} from "./flow-weaver-chunk-4DVY73ML.mjs";
+import "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-W3YNK26P.mjs";
+import {
+  VERSION
+} from "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import "./flow-weaver-chunk-Z44JK332.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/cli/commands/market.ts
+import * as fs from "fs";
+import * as path from "path";
+async function marketInitCommand(name, options = {}) {
+  if (!name.startsWith("flow-weaver-pack-")) {
+    const suggested = `flow-weaver-pack-${name}`;
+    logger.warn(`Name should follow "flow-weaver-pack-*" convention, using "${suggested}"`);
+    name = suggested;
+  }
+  const targetDir = path.resolve(name);
+  if (fs.existsSync(targetDir)) {
+    const stat = fs.statSync(targetDir);
+    if (stat.isDirectory()) {
+      const contents = fs.readdirSync(targetDir);
+      if (contents.length > 0) {
+        throw new Error(`Directory "${name}" already exists and is not empty`);
+      }
+    } else {
+      throw new Error(`"${name}" already exists and is not a directory`);
+    }
+  }
+  logger.section("Creating Marketplace Package");
+  logger.info(`Package: ${name}`);
+  logger.newline();
+  const dirs = [
+    targetDir,
+    path.join(targetDir, "src"),
+    path.join(targetDir, "src", "node-types"),
+    path.join(targetDir, "src", "workflows")
+  ];
+  for (const dir of dirs) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const shortName = name.replace(/^flow-weaver-pack-/, "");
+  const pkg = {
+    name,
+    version: "1.0.0",
+    description: options.description ?? `Flow Weaver marketplace pack: ${shortName}`,
+    type: "module",
+    main: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    keywords: ["flow-weaver-marketplace-pack", "flow-weaver", shortName],
+    flowWeaver: {
+      type: "marketplace-pack",
+      engineVersion: `>=${VERSION}`
+    },
+    scripts: {
+      build: "tsc",
+      pack: "fw market pack",
+      prepublishOnly: "npm run build && npm run pack"
+    },
+    ...options.author && { author: options.author },
+    license: "MIT",
+    peerDependencies: {
+      "@synergenius/flow-weaver": `>=${VERSION}`
+    },
+    devDependencies: {
+      "@synergenius/flow-weaver": `^${VERSION}`,
+      typescript: "^5.3.0"
+    },
+    files: ["dist", "flowweaver.manifest.json", "README.md", "LICENSE"]
+  };
+  fs.writeFileSync(
+    path.join(targetDir, "package.json"),
+    JSON.stringify(pkg, null, 2) + "\n"
+  );
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      declaration: true,
+      outDir: "./dist",
+      rootDir: "./src",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true
+    },
+    include: ["src"],
+    exclude: ["node_modules", "dist"]
+  };
+  fs.writeFileSync(
+    path.join(targetDir, "tsconfig.json"),
+    JSON.stringify(tsconfig, null, 2) + "\n"
+  );
+  const sampleNodeType = `/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Sample
+ * @description A sample node type for your marketplace pack
+ * @color blue
+ * @icon inventory
+ * @tag ${shortName}
+ */
+export function sample(data: string): { result: string } {
+  return { result: data.toUpperCase() };
+}
+`;
+  fs.writeFileSync(path.join(targetDir, "src", "node-types", "sample.ts"), sampleNodeType);
+  fs.writeFileSync(
+    path.join(targetDir, "src", "node-types", "index.ts"),
+    "export { sample } from './sample.js';\n"
+  );
+  fs.writeFileSync(
+    path.join(targetDir, "src", "workflows", "index.ts"),
+    "// Export workflows here\n"
+  );
+  fs.writeFileSync(
+    path.join(targetDir, "src", "index.ts"),
+    [
+      "export * from './node-types/index.js';",
+      "export * from './workflows/index.js';",
+      ""
+    ].join("\n")
+  );
+  const readme = `# ${name}
+
+A [Flow Weaver](https://github.com/synergenius-fw/flow-weaver) marketplace pack.
+
+## Installation
+
+\`\`\`bash
+fw market install ${name}
+\`\`\`
+
+## Contents
+
+### Node Types
+
+- **Sample**: a sample node type in src/node-types/sample.ts. Add yours beside it and re-export them from src/index.ts
+
+## Development
+
+\`\`\`bash
+npm install
+npm run build
+npm run pack    # Generate flowweaver.manifest.json
+npm publish     # Publish to npm
+\`\`\`
+`;
+  fs.writeFileSync(path.join(targetDir, "README.md"), readme);
+  fs.writeFileSync(
+    path.join(targetDir, ".gitignore"),
+    ["node_modules", "dist", "*.tgz", ""].join("\n")
+  );
+  logger.success("Created package.json");
+  logger.success("Created tsconfig.json");
+  logger.success("Created src/node-types/sample.ts");
+  logger.success("Created src/index.ts");
+  logger.success("Created README.md");
+  logger.success("Created .gitignore");
+  logger.newline();
+  logger.section("Next Steps");
+  logger.log(`  cd ${name}`);
+  logger.log("  npm install");
+  logger.log("  # Add your node types and workflows to src/");
+  logger.log("  npm run build");
+  logger.log("  fw market pack");
+  logger.log("  npm publish");
+  logger.newline();
+}
+async function marketPackCommand(directory, options = {}) {
+  const dir = path.resolve(directory ?? ".");
+  const { json = false, verbose = false } = options;
+  if (!json) {
+    logger.section("Packing Marketplace Package");
+  }
+  const { manifest, parsedFiles, errors: parseErrors } = await generateManifest({ directory: dir });
+  if (parseErrors.length > 0 && verbose) {
+    for (const err of parseErrors) {
+      logger.warn(err);
+    }
+  }
+  const validation = await validatePackage(dir, manifest);
+  if (json) {
+    console.log(JSON.stringify({
+      manifest,
+      validation,
+      parsedFiles: parsedFiles.length
+    }, null, 2));
+    if (!validation.valid) {
+      process.exitCode = 1;
+    }
+    return;
+  }
+  logger.info(`Parsed ${parsedFiles.length} file(s)`);
+  logger.info(`Found ${manifest.nodeTypes.length} node type(s), ${manifest.workflows.length} workflow(s)`);
+  logger.newline();
+  const errors = validation.issues.filter((i) => i.severity === "error");
+  const warnings = validation.issues.filter((i) => i.severity === "warning");
+  for (const err of errors) {
+    logger.error(`[${err.code}] ${err.message}`);
+  }
+  for (const warn of warnings) {
+    logger.warn(`[${warn.code}] ${warn.message}`);
+  }
+  if (!validation.valid) {
+    logger.newline();
+    throw new Error("Package validation failed. Fix errors above before publishing.");
+  }
+  const outPath = writeManifest(dir, manifest);
+  logger.newline();
+  logger.success(`Manifest written to ${path.relative(dir, outPath)}`);
+  if (warnings.length > 0) {
+    logger.warn(`${warnings.length} warning(s). Consider fixing before publishing`);
+  }
+  logger.newline();
+}
+async function marketPublishCommand(directory, options = {}) {
+  const dir = path.resolve(directory ?? ".");
+  const { dryRun = false, tag } = options;
+  logger.section("Publishing Marketplace Package");
+  await marketPackCommand(dir, { json: false });
+  if (!fs.existsSync(path.join(dir, "LICENSE"))) {
+    logger.warn("LICENSE file not found. Consider adding one");
+  }
+  const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf-8"));
+  logger.info(`Publishing ${pkg.name}@${pkg.version}`);
+  const npmArgs = ["publish"];
+  if (dryRun) npmArgs.push("--dry-run");
+  if (tag) npmArgs.push("--tag", tag);
+  try {
+    logger.newline();
+    runNpm(npmArgs, { cwd: dir, stdio: "inherit" });
+    if (!dryRun) {
+      logger.newline();
+      logger.success(`Published ${pkg.name}@${pkg.version} to npm`);
+    }
+  } catch (err) {
+    throw new Error(`npm publish failed: ${getErrorMessage(err)}`, { cause: err });
+  }
+}
+async function marketInstallCommand(packageSpec, options = {}) {
+  const { json = false } = options;
+  if (!json) {
+    logger.section("Installing Marketplace Package");
+    logger.info(`Installing ${packageSpec}...`);
+    logger.newline();
+  }
+  try {
+    npmInstall(packageSpec, { stdio: json ? "pipe" : "inherit" });
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ success: false, error: getErrorMessage(err) }));
+    } else {
+      logger.error(`npm install failed: ${getErrorMessage(err)}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const packageName = resolvePackageName(packageSpec);
+  const manifest = readManifest(path.join(process.cwd(), "node_modules", packageName));
+  if (json) {
+    console.log(JSON.stringify({
+      success: true,
+      package: packageName,
+      manifest: manifest ?? "no manifest found"
+    }, null, 2));
+    return;
+  }
+  logger.newline();
+  logger.success(`Installed ${packageName}`);
+  logger.newline();
+  if (manifest) {
+    displayManifestSummary(manifest);
+  } else {
+    logger.warn("No flowweaver.manifest.json found in package");
+    logger.info('The package may need to run "fw market pack" before publishing');
+  }
+}
+async function marketSearchCommand(query, options = {}) {
+  const { limit = 20, json = false, registry } = options;
+  if (!json) {
+    logger.section("Marketplace Search");
+    if (query) logger.info(`Query: ${query}`);
+    if (registry) logger.info(`Registry: ${registry}`);
+    logger.newline();
+  }
+  try {
+    let results;
+    if (registry) {
+      results = await searchPackages({ query, limit, registryUrl: registry });
+    } else {
+      const multi = await searchAllRegistries({ query, limit, projectDir: process.cwd() });
+      results = multi.results;
+      if (!json) {
+        for (const s of multi.searched) {
+          const scopes = s.scopes.length ? ` (${s.scopes.join(", ")})` : "";
+          if (s.ok) logger.info(`Searched ${s.url}${scopes}: ${s.count} pack(s)`);
+          else logger.warn(`Could not search ${s.url}${scopes}: ${s.error}`);
+        }
+        logger.newline();
+      }
+    }
+    if (query) {
+      const q = query.toLowerCase();
+      results = results.filter(
+        (pkg) => pkg.name.toLowerCase().includes(q) || pkg.description && pkg.description.toLowerCase().includes(q)
+      );
+    }
+    if (json) {
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+    if (results.length === 0) {
+      logger.info(query ? `No packages matching "${query}"` : "No packages found");
+      return;
+    }
+    for (const pkg of results) {
+      const badge = pkg.official ? " [official]" : "";
+      logger.log(`  ${pkg.name}@${pkg.version}${badge}`);
+      if (pkg.description) {
+        logger.log(`    ${pkg.description}`);
+      }
+      logger.newline();
+    }
+    logger.info(`${results.length} package(s) found`);
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ error: getErrorMessage(err) }));
+    } else {
+      logger.error(`Search failed: ${getErrorMessage(err)}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+}
+async function marketListCommand(options = {}) {
+  const { json = false } = options;
+  if (!json) {
+    logger.section("Installed Marketplace Packages");
+    logger.newline();
+  }
+  const packages = await listInstalledPackages(process.cwd());
+  if (json) {
+    console.log(JSON.stringify(packages.map((p) => ({
+      name: p.name,
+      version: p.version,
+      nodeTypes: p.manifest.nodeTypes.length,
+      workflows: p.manifest.workflows.length
+    })), null, 2));
+    return;
+  }
+  if (packages.length === 0) {
+    logger.info("No marketplace packages installed");
+    logger.info('Use "fw market search" to find packages');
+    return;
+  }
+  for (const pkg of packages) {
+    displayInstalledPackage(pkg);
+  }
+  logger.info(`${packages.length} package(s) installed`);
+}
+function resolvePackageName(spec) {
+  if (spec.endsWith(".tgz") || spec.endsWith(".tar.gz")) {
+    const base = path.basename(spec, spec.endsWith(".tar.gz") ? ".tar.gz" : ".tgz");
+    const match = base.match(/^(.+)-\d+\.\d+\.\d+/);
+    return match ? match[1] : base;
+  }
+  if (spec.startsWith("@")) {
+    const atIndex2 = spec.indexOf("@", 1);
+    return atIndex2 > 0 ? spec.slice(0, atIndex2) : spec;
+  }
+  const atIndex = spec.indexOf("@");
+  return atIndex > 0 ? spec.slice(0, atIndex) : spec;
+}
+function displayManifestSummary(manifest) {
+  if (manifest.nodeTypes.length > 0) {
+    logger.log("  Node Types:");
+    for (const nt of manifest.nodeTypes) {
+      const desc = nt.description ? `: ${nt.description}` : "";
+      logger.log(`    - ${nt.name}${desc}`);
+    }
+  }
+  if (manifest.workflows.length > 0) {
+    logger.log("  Workflows:");
+    for (const wf of manifest.workflows) {
+      const desc = wf.description ? `: ${wf.description}` : "";
+      logger.log(`    - ${wf.name}${desc}`);
+    }
+  }
+  logger.newline();
+}
+function displayInstalledPackage(pkg) {
+  const m = pkg.manifest;
+  logger.log(`  ${pkg.name}@${pkg.version}`);
+  const counts = [];
+  if (m.nodeTypes.length > 0) counts.push(`${m.nodeTypes.length} node type(s)`);
+  if (m.workflows.length > 0) counts.push(`${m.workflows.length} workflow(s)`);
+  if (counts.length > 0) {
+    logger.log(`    ${counts.join(", ")}`);
+  }
+  logger.newline();
+}
+export {
+  marketInitCommand,
+  marketInstallCommand,
+  marketListCommand,
+  marketPackCommand,
+  marketPublishCommand,
+  marketSearchCommand
+};

package/dist/cli/flow-weaver-mcp-setup-O26MGXSD.mjs

@@ -0,0 +1,22 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  CLI_TOOL_BINARY,
+  TOOL_REGISTRY,
+  detectCliTools,
+  detectTools,
+  mcpSetupCommand,
+  mergeJsonConfig,
+  runMcpSetupFromInit
+} from "./flow-weaver-chunk-PUWZ47H5.mjs";
+import "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+export {
+  CLI_TOOL_BINARY,
+  TOOL_REGISTRY,
+  detectCliTools,
+  detectTools,
+  mcpSetupCommand,
+  mergeJsonConfig,
+  runMcpSetupFromInit
+};

package/dist/cli/flow-weaver-migrate-VFVEUTPH.mjs

@@ -0,0 +1,119 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import "./flow-weaver-chunk-265CEK74.mjs";
+import {
+  applyMigrations,
+  formatDiff,
+  getRegisteredMigrations
+} from "./flow-weaver-chunk-I4APCXYN.mjs";
+import "./flow-weaver-chunk-3ZLMPQTH.mjs";
+import {
+  WorkflowDiffer
+} from "./flow-weaver-chunk-7ET6N32V.mjs";
+import "./flow-weaver-chunk-MMV2XGD3.mjs";
+import "./flow-weaver-chunk-NQKKWDGF.mjs";
+import "./flow-weaver-chunk-V6DHWFQG.mjs";
+import "./flow-weaver-chunk-4DVY73ML.mjs";
+import "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import {
+  safeWriteFile
+} from "./flow-weaver-chunk-NYZDQYFU.mjs";
+import {
+  generateInPlace
+} from "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  parseWorkflow
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import "./flow-weaver-chunk-BHCC5FE5.mjs";
+import "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import "./flow-weaver-chunk-Z44JK332.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import {
+  ts
+} from "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/cli/commands/migrate.ts
+import * as fs from "fs";
+import * as path from "path";
+async function migrateCommand(globPattern, options = {}) {
+  const { dryRun = false, diff = false } = options;
+  const files = ts(globPattern, { ignore: ["**/node_modules/**", "**/*.generated.ts"] });
+  if (files.length === 0) {
+    logger.warn(`No files matched pattern: ${globPattern}`);
+    return;
+  }
+  const registeredMigrations = getRegisteredMigrations();
+  if (registeredMigrations.length > 0) {
+    logger.info(`Registered edge-case migrations: ${registeredMigrations.map((m) => m.name).join(", ")}`);
+  }
+  const t = logger.timer();
+  let migratedCount = 0;
+  let skippedCount = 0;
+  let errorCount = 0;
+  for (const file of files) {
+    const filePath = path.resolve(file);
+    try {
+      const sourceCode = fs.readFileSync(filePath, "utf8");
+      const parseResult = await parseWorkflow(filePath);
+      if (parseResult.errors.length > 0) {
+        logger.error(`  ${file}: parse errors, skipping`);
+        parseResult.errors.forEach((err) => logger.error(`    ${err}`));
+        errorCount++;
+        continue;
+      }
+      let ast = parseResult.ast;
+      ast = applyMigrations(ast);
+      const genResult = generateInPlace(sourceCode, ast, {
+        allWorkflows: parseResult.allWorkflows
+      });
+      if (!genResult.hasChanges) {
+        skippedCount++;
+        continue;
+      }
+      if (diff) {
+        const reparsed = await parseWorkflow(filePath);
+        if (reparsed.errors.length === 0) {
+          const semanticDiff = WorkflowDiffer.compare(parseResult.ast, ast);
+          if (!semanticDiff.identical) {
+            logger.info(`
+${file}:`);
+            console.log(formatDiff(semanticDiff, "text"));
+          }
+        }
+      }
+      if (dryRun) {
+        logger.info(`  ${file}: would be updated`);
+        migratedCount++;
+        continue;
+      }
+      safeWriteFile(filePath, genResult.code);
+      logger.success(`  ${file}: migrated`);
+      migratedCount++;
+    } catch (error) {
+      logger.error(`  ${file}: ${getErrorMessage(error)}`);
+      errorCount++;
+    }
+  }
+  logger.newline();
+  if (dryRun) {
+    logger.info(`Dry run: ${migratedCount} file(s) would be updated, ${skippedCount} already current, ${errorCount} error(s) in ${t.elapsed()}`);
+  } else {
+    logger.info(`${migratedCount} file(s) migrated, ${skippedCount} already current, ${errorCount} error(s) in ${t.elapsed()}`);
+  }
+}
+export {
+  migrateCommand
+};