@bx-h/meta-flow 0.1.0

package/src/cli/lib/logger.js

@@ -0,0 +1,23 @@
+export function createLogger(options = {}) {
+  const verbose = Boolean(options.verbose);
+
+  return {
+    info(message) {
+      console.log(message);
+    },
+    warn(message) {
+      console.warn(`WARN: ${message}`);
+    },
+    fail(message) {
+      console.error(`FAIL: ${message}`);
+    },
+    pass(message) {
+      console.log(`PASS: ${message}`);
+    },
+    verbose(message) {
+      if (verbose) {
+        console.log(message);
+      }
+    }
+  };
+}

package/src/cli/lib/marketplace.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { readJsonOrDefault, writeJsonPretty } from "./fs_safe.js";
+import { repoMarketplacePath } from "./paths.js";
+
+export function marketplaceEntry(targets) {
+  return {
+    name: "meta-flow",
+    version: "0.1.0",
+    source: {
+      source: "local",
+      path: targets.scope === "repo" ? repoMarketplacePath() : targets.pluginTarget
+    },
+    policy: {
+      installation: "AVAILABLE",
+      authentication: "ON_INSTALL"
+    },
+    category: "Productivity"
+  };
+}
+
+export function mergeMarketplace(existing, entry) {
+  const marketplace = existing && typeof existing === "object" ? structuredClone(existing) : {};
+  if (!marketplace.name) {
+    marketplace.name = "meta-flow-marketplace";
+  }
+  if (!marketplace.interface) {
+    marketplace.interface = { displayName: "Meta Flow Marketplace" };
+  }
+  if (!Array.isArray(marketplace.plugins)) {
+    marketplace.plugins = [];
+  }
+  const index = marketplace.plugins.findIndex((plugin) => plugin?.name === entry.name);
+  if (index >= 0) {
+    marketplace.plugins[index] = { ...marketplace.plugins[index], ...entry };
+  } else {
+    marketplace.plugins.push(entry);
+  }
+  return marketplace;
+}
+
+export function removeMarketplaceEntry(existing, name = "meta-flow") {
+  const marketplace = existing && typeof existing === "object" ? structuredClone(existing) : {};
+  if (!Array.isArray(marketplace.plugins)) {
+    marketplace.plugins = [];
+  }
+  marketplace.plugins = marketplace.plugins.filter((plugin) => plugin?.name !== name);
+  return marketplace;
+}
+
+export async function updateMarketplace(targets, options = {}) {
+  const current = await readJsonOrDefault(targets.marketplaceTarget, {
+    name: "meta-flow-marketplace",
+    interface: { displayName: "Meta Flow Marketplace" },
+    plugins: []
+  });
+  const next = mergeMarketplace(current, marketplaceEntry(targets));
+  await writeJsonPretty(targets.marketplaceTarget, next, options);
+}
+
+export async function uninstallMarketplace(targets, options = {}) {
+  const current = await readJsonOrDefault(targets.marketplaceTarget, {
+    name: "meta-flow-marketplace",
+    interface: { displayName: "Meta Flow Marketplace" },
+    plugins: []
+  });
+  const next = removeMarketplaceEntry(current);
+  await writeJsonPretty(targets.marketplaceTarget, next, options);
+}
+
+export function describeMarketplace(targets) {
+  return path.resolve(targets.marketplaceTarget);
+}

package/src/cli/lib/paths.js

@@ -0,0 +1,37 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const thisFile = fileURLToPath(import.meta.url);
+export const packageRoot = path.resolve(path.dirname(thisFile), "../../..");
+export const pluginSource = path.join(packageRoot, "plugin");
+export const agentTemplatesSource = path.join(pluginSource, "agent-templates");
+export const marketplaceSource = path.join(packageRoot, "marketplace", "marketplace.json");
+export const examplesRoot = path.join(packageRoot, "examples");
+export const sampleTaskRoot = path.join(examplesRoot, "sample-task");
+
+export function resolveTargets({ scope = "repo", target } = {}) {
+  if (!["repo", "user"].includes(scope)) {
+    throw new Error("--scope must be repo or user");
+  }
+
+  const base = scope === "user"
+    ? os.homedir()
+    : path.resolve(target || process.cwd());
+
+  return {
+    scope,
+    target: base,
+    pluginTarget: scope === "user"
+      ? path.join(base, ".codex", "plugins", "meta-flow")
+      : path.join(base, "plugins", "meta-flow"),
+    marketplaceTarget: path.join(base, ".agents", "plugins", "marketplace.json"),
+    agentsTarget: path.join(base, ".codex", "agents"),
+    codexConfigTarget: path.join(base, ".codex", "config.toml"),
+    tasksTarget: path.join(base, ".meta-flow", "tasks")
+  };
+}
+
+export function repoMarketplacePath() {
+  return "./plugins/meta-flow";
+}

package/src/cli/lib/plugin.js

@@ -0,0 +1,57 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { backupIfExists, copyDirSafe, pathExists, removeDirSafe } from "./fs_safe.js";
+import { pluginSource } from "./paths.js";
+
+async function isMetaFlowPlugin(dir) {
+  try {
+    const manifest = JSON.parse(await fs.readFile(path.join(dir, ".codex-plugin", "plugin.json"), "utf8"));
+    return manifest.name === "meta-flow";
+  } catch {
+    return false;
+  }
+}
+
+export async function installPlugin(targets, options = {}) {
+  const { dryRun = false, force = false, logger } = options;
+  if (await pathExists(targets.pluginTarget)) {
+    if (!(await isMetaFlowPlugin(targets.pluginTarget)) && !force) {
+      return { installed: false, conflict: targets.pluginTarget };
+    }
+    if (force) {
+      await backupIfExists(targets.pluginTarget, { dryRun, logger });
+    }
+  }
+  await copyDirSafe(pluginSource, targets.pluginTarget, { dryRun, logger });
+  return { installed: true, conflict: null };
+}
+
+export async function uninstallPlugin(targets, options = {}) {
+  if (!(await pathExists(targets.pluginTarget))) {
+    return { removed: false, skipped: false };
+  }
+  if (!(await isMetaFlowPlugin(targets.pluginTarget))) {
+    return { removed: false, skipped: true };
+  }
+  const parent = path.dirname(targets.pluginTarget);
+  await removeDirSafe(parent, targets.pluginTarget, options);
+  return { removed: true, skipped: false };
+}
+
+export async function validatePlugin(root = pluginSource) {
+  const manifestPath = path.join(root, ".codex-plugin", "plugin.json");
+  const skillPath = path.join(root, "skills", "meta-flow", "SKILL.md");
+  const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+  const skill = await fs.readFile(skillPath, "utf8");
+  const errors = [];
+  if (manifest.name !== "meta-flow") {
+    errors.push("plugin manifest name must be meta-flow");
+  }
+  if (manifest.version !== "0.1.0") {
+    errors.push("plugin manifest version must be 0.1.0");
+  }
+  if (!/^---\n[\s\S]*?name:\s*meta-flow[\s\S]*?---/m.test(skill)) {
+    errors.push("SKILL.md frontmatter must contain name: meta-flow");
+  }
+  return { manifestPath, skillPath, errors };
+}