@merchantduo/code 0.1.0-beta.0 → 0.2.0-beta.0

package/dist/magento.js

@@ -1,119 +0,0 @@
-/**
- * Build a registered-theme graph. Metadata is accepted only from registration.php
- * locations and theme.xml values; malformed/missing parents remain non-fatal.
- */
-export function resolveThemes(themes) {
-    const byCode = new Map(themes.map((theme) => [theme.code, theme]));
-    const lineage = (theme) => {
-        const chain = [];
-        const seen = new Set([theme.code]);
-        let parent = theme.parent;
-        while (parent && !seen.has(parent)) {
-            chain.push(parent);
-            seen.add(parent);
-            parent = byCode.get(parent)?.parent;
-        }
-        return chain;
-    };
-    return themes.map((theme) => {
-        const parentChain = lineage(theme);
-        const ancestry = [theme.code, ...parentChain];
-        return {
-            code: theme.code,
-            title: theme.title,
-            path: theme.path,
-            parentChain,
-            kind: ancestry.includes("Magento/luma")
-                ? "luma"
-                : ancestry.includes("Hyva/default") || ancestry.includes("Hyva/reset")
-                    ? "hyva"
-                    : "other",
-        };
-    });
-}
-export function parseRegisteredThemes(output) {
-    return output
-        .split("\u001e")
-        .map((entry) => entry.trim())
-        .filter(Boolean)
-        .flatMap((entry) => {
-        try {
-            const value = JSON.parse(entry);
-            return typeof value.code === "string" && typeof value.path === "string"
-                ? [value]
-                : [];
-        }
-        catch {
-            return [];
-        }
-    });
-}
-/**
- * Accept only successful Magento CLI output that names one known deployment mode.
- * A failed or unrecognised probe must not influence operational recommendations.
- */
-export function parseDeployMode(output, exitCode) {
-    if (exitCode !== 0)
-        return undefined;
-    const mode = output.match(/\b(developer|production|default)\b/i)?.[1]?.toLowerCase();
-    return mode === "developer" || mode === "production" || mode === "default"
-        ? mode
-        : undefined;
-}
-export async function snapshot(backend) {
-    const warnings = [], evidence = [];
-    const composer = await backend.run([
-        "sh",
-        "-lc",
-        "test -f composer.lock && node -e \"const x=require('./composer.lock'); console.log(JSON.stringify(x.packages||[]))\" || true",
-    ]);
-    const packages = composer.stdout;
-    const match = packages.match(/magento\/(product-community-edition|product-enterprise-edition).*?\"version\":\"([^\"]+)/s);
-    const edition = match?.[1] === "product-enterprise-edition"
-        ? "Adobe Commerce"
-        : match
-            ? "Open Source"
-            : undefined;
-    const composerVersion = match?.[2];
-    if (composerVersion)
-        evidence.push("composer.lock");
-    const cli = await backend.run(["bin/magento", "--version"]);
-    const cliVersion = cli.stdout.match(/(?:Magento|Adobe Commerce)[^0-9]*(\d+\.\d+\.\d+(?:-[^\s]+)?)/)?.[1];
-    if (cliVersion)
-        evidence.push("bin/magento --version");
-    if (composerVersion && cliVersion && !cliVersion.startsWith(composerVersion))
-        warnings.push(`Composer (${composerVersion}) and CLI (${cliVersion}) disagree`);
-    const [php, mode, cache, modules] = await Promise.all([
-        backend.run(["php", "-r", "echo PHP_VERSION;"]),
-        backend.run(["bin/magento", "deploy:mode:show"]),
-        backend.run(["bin/magento", "cache:status", "--no-ansi"]),
-        backend.run(["bin/magento", "module:status", "--enabled", "--no-ansi"]),
-    ]);
-    // Magento themes live at package roots or app/design area/vendor/theme roots.
-    // Do not recurse through vendor test fixtures: they also carry registration.php.
-    const registeredThemes = await backend.run([
-        "sh",
-        "-lc",
-        `{
-      find vendor -mindepth 3 -maxdepth 3 -type f -name registration.php 2>/dev/null
-      find app/design -mindepth 4 -maxdepth 4 -type f -name registration.php 2>/dev/null
-    } | while read f; do d=$(dirname "$f"); x="$d/theme.xml"; [ -f "$x" ] || continue; code=$(sed -n "s/.*ComponentRegistrar::THEME[[:space:]]*,[[:space:]]*['\\\"]\\([^'\\\"]*\\).*/\\1/p" "$f" | head -1); [ -n "$code" ] || continue; title=$(sed -n 's:.*<title>\\(.*\\)</title>.*:\\1:p' "$x" | head -1); parent=$(sed -n 's:.*<parent>\\(.*\\)</parent>.*:\\1:p' "$x" | head -1); node -e 'console.log(JSON.stringify({code:process.argv[1],path:process.argv[2],title:process.argv[3]||undefined,parent:process.argv[4]||undefined})+"\\u001e")' "$code" "$d" "$title" "$parent"; done`,
-    ]);
-    return {
-        version: composerVersion ?? cliVersion,
-        edition,
-        phpVersion: php.stdout.trim() || undefined,
-        mode: parseDeployMode(mode.stdout, mode.exitCode),
-        cacheTypes: cache.stdout
-            .split("\n")
-            .map((l) => l.match(/^([^:]+):/)?.[1])
-            .filter((x) => Boolean(x)),
-        modulesEnabled: modules.stdout.split("\n").filter(Boolean).length || undefined,
-        warnings,
-        evidence,
-        themes: resolveThemes(parseRegisteredThemes(registeredThemes.stdout)),
-    };
-}
-export function snapshotPrompt(envName, writable, status, s) {
-    return `[MerchantDuo: environment=${envName}; write policy=${writable ? "writable" : "read-only"}; Magento=${s.edition ?? "unknown"} ${s.version ?? "unknown"}; PHP=${s.phpVersion ?? "unknown"}; mode=${s.mode ?? "unknown"}; MCP=${status}; pending actions are controlled by magento_workflow. Require exact detected edition/version in Magento knowledge MCP arguments. Do not inspect app/etc/env.php or credentials.${s.warnings.length ? ` Warnings: ${s.warnings.join("; ")}` : ""}]`;
-}

package/dist/magento.test.js

@@ -1,31 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { parseDeployMode, parseRegisteredThemes, resolveThemes } from "./magento.js";
-test("deployment mode parsing accepts each Magento mode and rejects unknown or failed probes", () => {
-    assert.equal(parseDeployMode("Current application mode: default", 0), "default");
-    assert.equal(parseDeployMode("Current application mode: developer", 0), "developer");
-    assert.equal(parseDeployMode("Current application mode: production", 0), "production");
-    assert.equal(parseDeployMode("Current application mode: staging", 0), undefined);
-    assert.equal(parseDeployMode("Current application mode: production", 1), undefined);
-});
-test("registered themes use metadata inheritance and classify descendants", () => {
-    const themes = resolveThemes([
-        { code: "Magento/luma", path: "vendor/magento/theme-frontend-luma", title: "Luma" },
-        { code: "Acme/store", path: "app/design/frontend/Acme/store", parent: "Magento/luma" },
-        { code: "Hyva/default", path: "vendor/hyva/default" },
-        { code: "Acme/hyva", path: "app/design/frontend/Acme/hyva", parent: "Hyva/default" },
-    ]);
-    assert.deepEqual(themes.find((theme) => theme.code === "Acme/store")?.parentChain, ["Magento/luma"]);
-    assert.equal(themes.find((theme) => theme.code === "Acme/store")?.kind, "luma");
-    assert.equal(themes.find((theme) => theme.code === "Acme/hyva")?.kind, "hyva");
-});
-test("theme metadata ignores malformed records and terminates cycles", () => {
-    assert.deepEqual(parseRegisteredThemes("bad\u001e{}"), []);
-    const themes = resolveThemes([
-        { code: "A/a", path: "a", parent: "B/b" },
-        { code: "B/b", path: "b", parent: "A/a" },
-        { code: "C/c", path: "c", parent: "Missing/x" },
-    ]);
-    assert.deepEqual(themes[0]?.parentChain, ["B/b"]);
-    assert.deepEqual(themes[2]?.parentChain, ["Missing/x"]);
-});

package/dist/skills.d.ts

@@ -1,11 +0,0 @@
-import type { MagentoTheme } from "./magento.js";
-export type SkillName = "magento-24x" | "luma" | "hyva" | "mage2gen";
-export declare function skillRoot(): string;
-export declare function mage2genRoot(): string;
-export declare function selectMagentoSkill(version?: string): SkillName | undefined;
-export declare function selectedThemeSkill(activeTheme: string, themes: MagentoTheme[]): SkillName | undefined;
-export declare function automaticSkills(version: string | undefined, activeTheme: string, themes: MagentoTheme[]): SkillName[];
-export declare function readSkill(name: SkillName): Promise<string>;
-export declare function skillPaths(): Record<SkillName, string>;
-/** MerchantDuo's stable session rules; environment-specific facts remain in snapshotPrompt. */
-export declare function merchantDuoSystemPrompt(mage2genPath?: string): string;

package/dist/skills.test.js

@@ -1,34 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { automaticSkills, merchantDuoSystemPrompt, readSkill, selectMagentoSkill } from "./skills.js";
-test("Magento skills use the longest supported version prefix", () => {
-    assert.equal(selectMagentoSkill("2.4.8-p1"), "magento-24x");
-    assert.equal(selectMagentoSkill("2.3.7"), undefined);
-});
-test("baseline session prompt establishes Mage2Gen, theme-scope, and mode-aware workflow guidance", () => {
-    const prompt = merchantDuoSystemPrompt();
-    assert.match(prompt, /senior Magento 2\.4 architect/);
-    assert.match(prompt, /vendor\/mage2gen/);
-    assert.match(prompt, /mage2gen_generate_module/);
-    assert.match(prompt, /active theme scope/);
-    assert.match(prompt, /sole authoritative confirmation/);
-    assert.match(prompt, /inspect the changed module and files/i);
-    assert.match(prompt, /developer recommends `setup:upgrade` then targeted cache clean/i);
-    assert.match(prompt, /default recommends `setup:upgrade` then targeted cache clean/i);
-    assert.match(prompt, /production recommends maintenance enable, `setup:upgrade`, DI compile, static-content deploy, targeted cache clean, then maintenance disable/i);
-    assert.match(prompt, /only this workflow tool for operational Magento commands/i);
-});
-test("Magento 2.4 skill records the mode matrix and workflow-only execution policy", async () => {
-    const skill = await readSkill("magento-24x");
-    assert.match(skill, /\| Developer \| Run `setup:upgrade`, then clean only relevant cache types\./);
-    assert.match(skill, /\| Default \| Run `setup:upgrade`, then clean only relevant cache types\./);
-    assert.match(skill, /\| Production \| Run maintenance enable → `setup:upgrade` → DI compile → static-content deploy → targeted cache clean → maintenance disable\./);
-    assert.match(skill, /Use `magento_workflow` rather than raw operational commands\./);
-    assert.match(skill, /call it with `execute: true` immediately/);
-});
-test("automatic theme skills require a concrete classified selection", () => {
-    const themes = [{ code: "Acme/hyva", path: "app/design", parentChain: ["Hyva/default"], kind: "hyva" }];
-    assert.deepEqual(automaticSkills("2.4.7", "all", themes), ["magento-24x"]);
-    assert.deepEqual(automaticSkills("2.4.7", "any", themes), ["magento-24x"]);
-    assert.deepEqual(automaticSkills("2.4.7", "Acme/hyva", themes), ["magento-24x", "hyva"]);
-});

package/dist/workflow.d.ts

@@ -1,20 +0,0 @@
-import type { Backend } from "./backend.js";
-import type { MagentoSnapshot } from "./magento.js";
-export type Pending = {
-    files: Set<string>;
-    cacheTypes: Set<string>;
-};
-export declare function classifyEdit(pending: Pending, file: string): void;
-export declare function safeCacheTypes(pending: Pending, snapshot: MagentoSnapshot): string[];
-export declare function syntaxCheck(backend: Backend, files: string[]): Promise<string[]>;
-export declare function runWorkflow(backend: Backend, action: WorkflowAction, cacheTypes?: string[]): Promise<{
-    command: {
-        file: string;
-        args: string[];
-        cwd?: string;
-    };
-    result: import("./backend.js").CommandResult;
-}>;
-export type WorkflowAction = "cache-clean" | "cache-flush" | "compile" | "setup-upgrade" | "maintenance-enable" | "maintenance-disable" | "static-content-deploy" | "reindex" | "tests";
-/** Build the exact Magento CLI invocation used by the confirmation-gated workflow. */
-export declare function workflowCommand(action: WorkflowAction, cacheTypes?: string[]): string[];

package/dist/workflow.js

@@ -1,67 +0,0 @@
-const CACHE = {
-    layout: ["layout", "block_html", "full_page"],
-    template: ["block_html", "full_page"],
-    xml: ["config", "layout", "block_html"],
-    di: ["config"],
-    graphql: ["config", "full_page"],
-};
-export function classifyEdit(pending, file) {
-    pending.files.add(file);
-    const lower = file.toLowerCase();
-    for (const [needle, types] of Object.entries(CACHE))
-        if (lower.includes(needle) || lower.endsWith(`.${needle}`))
-            types.forEach((t) => pending.cacheTypes.add(t));
-    if (lower.endsWith(".xml"))
-        CACHE.xml.forEach((t) => pending.cacheTypes.add(t));
-}
-export function safeCacheTypes(pending, snapshot) {
-    return [...pending.cacheTypes].filter((x) => snapshot.cacheTypes.includes(x));
-}
-export async function syntaxCheck(backend, files) {
-    const outcomes = [];
-    for (const file of files) {
-        const cmd = file.endsWith(".php")
-            ? ["php", "-l", backend.path(file)]
-            : file.endsWith(".xml")
-                ? ["xmllint", "--noout", backend.path(file)]
-                : file.endsWith(".json")
-                    ? [
-                        "node",
-                        "-e",
-                        `JSON.parse(require('fs').readFileSync(${JSON.stringify(backend.path(file))},'utf8'))`,
-                    ]
-                    : undefined;
-        if (cmd) {
-            const r = await backend.run(cmd);
-            outcomes.push(`${file}: ${r.exitCode === 0 ? "ok" : r.stderr || r.stdout}`);
-        }
-    }
-    return outcomes;
-}
-export async function runWorkflow(backend, action, cacheTypes = []) {
-    const cmd = workflowCommand(action, cacheTypes);
-    return { command: backend.command(cmd), result: await backend.run(cmd) };
-}
-/** Build the exact Magento CLI invocation used by the confirmation-gated workflow. */
-export function workflowCommand(action, cacheTypes = []) {
-    switch (action) {
-        case "cache-clean":
-            return ["bin/magento", "cache:clean", ...cacheTypes];
-        case "cache-flush":
-            return ["bin/magento", "cache:flush"];
-        case "compile":
-            return ["bin/magento", "setup:di:compile"];
-        case "setup-upgrade":
-            return ["bin/magento", "setup:upgrade"];
-        case "maintenance-enable":
-            return ["bin/magento", "maintenance:enable"];
-        case "maintenance-disable":
-            return ["bin/magento", "maintenance:disable"];
-        case "static-content-deploy":
-            return ["bin/magento", "setup:static-content:deploy"];
-        case "reindex":
-            return ["bin/magento", "indexer:reindex"];
-        case "tests":
-            return ["bin/magento", "dev:tests:run"];
-    }
-}

package/dist/workflow.test.js

@@ -1,17 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { workflowCommand } from "./workflow.js";
-test("workflow commands construct maintenance and default static deployment actions", () => {
-    assert.deepEqual(workflowCommand("maintenance-enable"), [
-        "bin/magento",
-        "maintenance:enable",
-    ]);
-    assert.deepEqual(workflowCommand("maintenance-disable"), [
-        "bin/magento",
-        "maintenance:disable",
-    ]);
-    assert.deepEqual(workflowCommand("static-content-deploy"), [
-        "bin/magento",
-        "setup:static-content:deploy",
-    ]);
-});

package/extensions/merchantduo.js

@@ -1,311 +0,0 @@
-// MerchantDuo Pi extension. It deliberately uses Pi lifecycle hooks and native tools;
-// no Pi fork or model-facing skills are required.
-import { Type } from "typebox";
-import { resolve } from "node:path";
-import { Backend } from "../dist/backend.js";
-import { loadConfig, selectEnvironment, setActiveTheme } from "../dist/config.js";
-import { KNOWLEDGE_MCP_URL, PROVIDER } from "../dist/constants.js";
-import { snapshot, snapshotPrompt } from "../dist/magento.js";
-import { automaticSkills, mage2genRoot, merchantDuoSystemPrompt, readSkill, skillPaths } from "../dist/skills.js";
-import { classifyEdit, runWorkflow, safeCacheTypes } from "../dist/workflow.js";
-import { generateMage2GenModule, mage2genDestination, mage2genModuleExists } from "../dist/mage2gen.js";
-
-export default function merchantDuo(pi) {
-  let state;
-  let injectionGeneration = 0;
-  const injected = new Set();
-  const pending = { files: new Set(), cacheTypes: new Set() };
-  const boot = async (ctx) => {
-    if (state) return state;
-    const { config } = await loadConfig(ctx.cwd, {
-      config: process.env.MERCHANTDUO_CONFIG_PATH || undefined,
-    });
-    const selected = selectEnvironment(
-      config,
-      ctx.cwd,
-      process.env.MERCHANTDUO_SELECTED_ENV,
-    );
-    const backend = new Backend(selected.environment, ctx.cwd);
-    const magento = await snapshot(backend);
-    state = {
-      config,
-      selected,
-      backend,
-      magento,
-      mcp: `${KNOWLEDGE_MCP_URL} (read-only)`,
-    };
-    refreshStatus(ctx, state);
-    return state;
-  };
-  const writePolicy = (s) =>
-    s.selected.environment.type === "ssh"
-      ? s.selected.environment.writable
-        ? "write + approve"
-        : "read-only + approve"
-      : "write + approve";
-  const refreshStatus = (ctx, s) => {
-    ctx.ui.setStatus(
-      "merchantduo",
-      `MerchantDuo ${process.env.MERCHANTDUO_PACKAGE_VERSION ?? "?"} | Magento ${s.magento.version ?? "?"} | ${s.selected.name}/${s.selected.environment.type} | ${writePolicy(s)} | Theme: ${s.config.activeTheme} (/theme to switch)`,
-    );
-  };
-  const resetInjection = () => {
-    injectionGeneration += 1;
-    injected.clear();
-  };
-  // Expose every shipped skill to Pi; automatic injection remains intentionally narrower.
-  pi.on("resources_discover", () => ({
-    skillPaths: [
-      new URL("../skills", import.meta.url).pathname,
-      new URL("../vendor/hyva-ai-tools/skills", import.meta.url).pathname,
-    ],
-  }));
-  // Register even without a key. Pi only selects it when an explicit API key makes it usable.
-  pi.registerProvider(PROVIDER.id, {
-    baseUrl: PROVIDER.baseUrl,
-    apiKey: "$MERCHANTDUO_API_KEY",
-    api: "openai-completions",
-    models: [
-      {
-        id: PROVIDER.model,
-        name: "MerchantDuo Mock (replace before production)",
-        input: [...PROVIDER.input],
-        reasoning: PROVIDER.reasoning,
-        contextWindow: PROVIDER.contextWindow,
-        maxTokens: PROVIDER.maxTokens,
-        cost: PROVIDER.cost,
-      },
-    ],
-  });
-  pi.on("before_agent_start", async (event, ctx) => {
-    const s = await boot(ctx);
-    const desired = automaticSkills(s.magento.version, s.config.activeTheme, s.magento.themes);
-    const pending = desired.filter((name) => !injected.has(`${injectionGeneration}:${name}:${s.config.activeTheme}`));
-    const instructions = await Promise.all(pending.map(readSkill));
-    pending.forEach((name) => injected.add(`${injectionGeneration}:${name}:${s.config.activeTheme}`));
-    return {
-      systemPrompt: `${event.systemPrompt}\n${merchantDuoSystemPrompt(mage2genRoot())}\n${snapshotPrompt(s.selected.name, s.selected.environment.type !== "ssh" || s.selected.environment.writable, s.mcp, s.magento)}\nMerchantDuo skills are available for explicit use at: ${Object.entries(skillPaths()).map(([name, path]) => `${name}=${path}`).join(", ")}.${instructions.length ? `\n\nMerchantDuo active instructions:\n${instructions.join("\n\n")}` : ""}`,
-    };
-  });
-  pi.on("session_start", async (_event, ctx) => {
-    await boot(ctx);
-    resetInjection();
-  });
-  pi.on("session_compact", () => resetInjection());
-  pi.registerCommand("theme", {
-    description: "Select the project theme scope: all, any, or a detected Magento theme.",
-    getArgumentCompletions: async () => {
-      if (!state) return ["all", "any"];
-      return ["all", "any", ...state.magento.themes.map((theme) => theme.code)].map((value) => ({ value, label: value }));
-    },
-    handler: async (args, ctx) => {
-      const s = await boot(ctx);
-      const choices = ["all", "any", ...s.magento.themes.map((theme) => theme.code)];
-      const requested = args.trim() || (await ctx.ui.select("Select Magento theme scope", choices));
-      if (!requested) return;
-      if (!choices.includes(requested)) {
-        ctx.ui.notify(`Unknown theme scope: ${requested}. Choose all, any, or a detected theme.`, "error");
-        return;
-      }
-      if (!process.env.MERCHANTDUO_CONFIG_PATH) {
-        ctx.ui.notify("No project .merchantduo.yaml is loaded; run merchantduo init before changing the theme.", "error");
-        return;
-      }
-      s.config = await setActiveTheme(process.env.MERCHANTDUO_CONFIG_PATH, requested);
-      resetInjection();
-      refreshStatus(ctx, s);
-      ctx.ui.notify(`Theme scope set to ${requested}; matching skills will apply to the next prompt.`, "info");
-    },
-  });
-  pi.on("tool_call", async (event, ctx) => {
-    const s = await boot(ctx);
-    const remote = s.selected.environment.type === "ssh";
-    if (
-      remote &&
-      ["write", "edit"].includes(event.toolName || "") &&
-      !s.selected.environment.writable
-    )
-      return {
-        block: true,
-        reason: "MerchantDuo: this SSH environment is read-only.",
-      };
-    if (
-      remote &&
-      ["bash", "read", "write", "edit", "grep", "find", "ls"].includes(
-        event.toolName || "",
-      )
-    ) {
-      const approved = ctx.hasUI
-        ? await ctx.ui.confirm(
-            "Remote command",
-            `Run ${event.toolName} on ${s.selected.environment.host}?`,
-          )
-        : false;
-      if (!approved)
-        return {
-          block: true,
-          reason: "MerchantDuo: remote command was not confirmed.",
-        };
-    }
-    if (["write", "edit"].includes(event.toolName || "")) {
-      const file = event.input.path || event.input.filePath;
-      if (typeof file === "string") classifyEdit(pending, file);
-    }
-  });
-  pi.on("tool_result", async (_event, ctx) => {
-    const s = await boot(ctx);
-    if (pending.files.size && s.config.automation.syntaxChecks === "auto")
-      ctx.ui.setStatus(
-        "merchantduo-actions",
-        `Pending syntax checks and cache recommendations for ${pending.files.size} edit(s)`,
-      );
-  });
-  pi.registerTool({
-    name: "mage2gen_generate_module",
-    label: "Generate Magento module",
-    description:
-      "Generate initial Magento module scaffolding through the vendored Mage2Gen library. Use this for every new-module request before custom implementation. A direct user request with execute=true receives one authoritative write confirmation.",
-    parameters: Type.Object({
-      vendor: Type.String({ description: "Magento module vendor, for example Perspective" }),
-      module: Type.String({ description: "Magento module name, for example FreshStocks" }),
-      description: Type.Optional(Type.String()),
-      frontendRoute: Type.Optional(Type.String({ description: "Optional frontend route id/frontName" })),
-      section: Type.Optional(Type.String({ description: "Frontend controller section; defaults to index" })),
-      action: Type.Optional(Type.String({ description: "Frontend controller action; defaults to index" })),
-      execute: Type.Optional(Type.Boolean()),
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const s = await boot(ctx);
-      if (!/^[A-Z][A-Za-z0-9]*$/.test(params.vendor) || !/^[A-Z][A-Za-z0-9]*$/.test(params.module))
-        return { content: [{ type: "text", text: "Mage2Gen requires PascalCase vendor and module names." }], details: {} };
-      if (s.selected.environment.type === "ssh")
-        return { content: [{ type: "text", text: "Mage2Gen generation is unavailable for SSH: the vendored Python library runs on the local project workspace." }], details: {} };
-      const projectRoot = s.selected.environment.type === "warden"
-        ? resolve(ctx.cwd, s.selected.environment.projectRoot)
-        : resolve(ctx.cwd, s.selected.environment.root);
-      const request = {
-        mage2genRoot: mage2genRoot(),
-        projectRoot,
-        vendor: params.vendor,
-        module: params.module,
-        description: params.description,
-        frontend: params.frontendRoute
-          ? { route: params.frontendRoute, section: params.section ?? "index", action: params.action ?? "index" }
-          : undefined,
-      };
-      const destination = mage2genDestination(projectRoot, params.vendor, params.module);
-      if (await mage2genModuleExists(request))
-        return { content: [{ type: "text", text: `Refused: module destination already exists: ${destination}` }], details: {} };
-      if (!params.execute)
-        return { content: [{ type: "text", text: `Preview: Mage2Gen will create ${destination}${request.frontend ? ` with frontend route ${request.frontend.route}/${request.frontend.section}/${request.frontend.action}` : ""}. Set execute=true after the user's direct request.` }], details: {} };
-      if (!(ctx.hasUI && await ctx.ui.confirm("Generate Magento module", `Generate ${params.vendor}_${params.module} at ${destination}?`)))
-        return { content: [{ type: "text", text: "Cancelled: confirmation required." }], details: {} };
-      try {
-        const generated = await generateMage2GenModule(request);
-        return { content: [{ type: "text", text: `Mage2Gen created ${params.vendor}_${params.module} at ${generated}. Inspect and adapt the generated files before continuing.` }], details: {} };
-      } catch (error) {
-        return { content: [{ type: "text", text: `Mage2Gen failed: ${error.message}` }], details: {} };
-      }
-    },
-  });
-  pi.registerTool({
-    name: "magento_workflow",
-    label: "Magento workflow",
-    description:
-      "Preview or run an explicit Magento operational workflow. If the user directly requests execution, call with execute=true; MerchantDuo presents the sole authoritative confirmation dialog for risky actions. Do not ask for a separate conversational confirmation.",
-    parameters: Type.Object({
-      action: Type.Union([
-        Type.Literal("status"),
-        Type.Literal("syntax-check"),
-        Type.Literal("cache-clean"),
-        Type.Literal("cache-flush"),
-        Type.Literal("compile"),
-        Type.Literal("setup-upgrade"),
-        Type.Literal("maintenance-enable"),
-        Type.Literal("maintenance-disable"),
-        Type.Literal("static-content-deploy"),
-        Type.Literal("reindex"),
-        Type.Literal("tests"),
-      ]),
-      execute: Type.Optional(Type.Boolean()),
-    }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const s = await boot(ctx);
-      if (params.action === "status")
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  snapshot: s.magento,
-                  pendingFiles: [...pending.files],
-                  safeCacheTypes: safeCacheTypes(pending, s.magento),
-                },
-                null,
-                2,
-              ),
-            },
-          ],
-          details: {},
-        };
-      if (params.action === "syntax-check")
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Syntax checks are pending for: ${[...pending.files].join(", ") || "none"}`,
-            },
-          ],
-          details: {},
-        };
-      if (!params.execute)
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Preview only. Set execute=true after confirmation. Action: ${params.action}`,
-            },
-          ],
-          details: {},
-        };
-      const risky = params.action !== "cache-clean";
-      if (
-        risky &&
-        !(
-          ctx.hasUI &&
-          (await ctx.ui.confirm(
-            "Confirm Magento action",
-            `Execute ${params.action}?`,
-          ))
-        )
-      )
-        return {
-          content: [
-            { type: "text", text: "Cancelled: confirmation required." },
-          ],
-          details: {},
-        };
-      if (s.selected.environment.type === "ssh")
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Remote mutations require a separately confirmed SSH command; workflow execution is refused here.",
-            },
-          ],
-          details: {},
-        };
-      const action = params.action;
-      const result = await runWorkflow(
-        s.backend,
-        action,
-        action === "cache-clean" ? safeCacheTypes(pending, s.magento) : [],
-      );
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        details: {},
-      };
-    },
-  });
-}