@merchantduo/code 0.2.0-beta.5 → 0.3.0-beta.0

package/README.md

@@ -6,17 +6,17 @@ MerchantDuo is a Pi coding agent for Magento 2.4 teams. It starts from the store
 
 - Works with local checkouts, Warden, and SSH environments.
 - Detects Magento edition, version, PHP version, deployment mode, cache types, and registered theme inheritance.
-- Ships Magento 2.4, Luma, Hyva, Mage2Gen, and testing skills.
+- Ships Magento 2.4, Luma, Hyva, Mage2Gen, testing, and persistent-goal skills.
 - Provides guided local/Warden store provisioning.
 - Keeps remote writes and Magento operations behind explicit execution boundaries.
 
-At session start, MerchantDuo produces a Magento snapshot from the selected environment. Frontend and admin URLs are discovered but remain unverified until an explicit test. The compact status line shows MerchantDuo and Magento versions, environment lifecycle, session permission mode, an explicit theme scope when one is selected, and the frontend URL when available.
+At session start, MerchantDuo produces a Magento snapshot from the selected environment. Frontend and admin URLs are discovered but remain unverified until an explicit test. The compact status line shows the Magento version, environment lifecycle, session permission mode, an explicit theme scope when one is selected, and the frontend URL when available.
 
 ## Commands and tools
 
 Extension slash commands are namespaced with `duo-` to avoid collisions with other Pi extensions.
 
-- [Command reference](docs/commands.md) covers session theme and permission switching, lifecycle, and navigation commands.
+- [Command reference](docs/commands.md) covers session theme and permission switching, lifecycle, navigation, and bundled persistent-goal commands.
 - [Tool reference](docs/tools.md) covers workspace, environment, Magento workflow, magerun2, testing, PHP-console, and optional knowledge tools, including parameters and confirmation boundaries.
 
 ## Environments
@@ -73,7 +73,7 @@ The interactive flow discovers available source, database, and service evidence,
 
 ## Install and start
 
-MerchantDuo requires Node.js 22.19 or later, Bash, and Python 3. HTTP/browser testing additionally needs curl and Chrome or Chromium; Warden and SSH environments need Warden and OpenSSH respectively.
+MerchantDuo requires Node.js 22.19 or later, Bash, and Python 3. HTTP/browser testing additionally needs curl and Chrome or Chromium. The bundled `fetch_content` internet-research tool runs over host HTTP and has no browser or Python-runner prerequisite. Warden and SSH environments need Warden and OpenSSH respectively.
 
 ```sh
 pnpm install --frozen-lockfile

package/dist/app/status.d.ts

@@ -1,3 +1,4 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { SessionState } from "#app/runtime";
+export declare function setInitializingStatus(ctx: ExtensionContext): void;
 export declare function refreshStatus(ctx: ExtensionContext, state: SessionState): void;

package/dist/app/status.js

@@ -1,6 +1,8 @@
+export function setInitializingStatus(ctx) {
+    ctx.ui.setStatus("merchantduo", "Initializing Magento context…");
+}
 export function refreshStatus(ctx, state) {
     const parts = [
-        `MerchantDuo ${process.env.MERCHANTDUO_PACKAGE_VERSION ?? "?"}`,
         `M${state.magento.version ?? "?"}`,
         `${state.selected.name} (${state.environmentStatus})`,
         state.permissionMode === "read-only" ? "r-o" : state.permissionMode,

package/dist/app/system-prompt.js

@@ -5,6 +5,8 @@ export function mage2genRoot() {
 export function merchantDuoSystemPrompt(mage2genPath = mage2genRoot()) {
     return `You are MerchantDuo, a senior Magento 2.4 architect and implementation partner. Work directly in the selected MerchantDuo environment and theme scope. Before changing code, inspect the relevant module, theme inheritance chain, configuration, and established local conventions. Make focused, production-quality changes; do not preserve obsolete compatibility paths or add speculative abstractions.
 
+Ground every design and implementation decision in existing source before introducing a pattern. Find the closest applicable example and read its surrounding call sites, configuration, and tests. Search Magento core under vendor/magento first; if it has no suitable example, search other installed vendor modules or project app/code modules. Adapt the applicable pattern rather than copying blindly, and explain any material intentional difference. Only when no relevant precedent exists may you introduce a new pattern, and state that finding before doing so.
+
 Use Magento service contracts, dependency injection, declarative schema/data patches, layout XML, and theme fallback mechanisms when they are the correct native extension points. Respect the active theme scope: all means cover every detected theme, any means identify the relevant theme from the request and code before theme-specific edits, and a concrete theme limits work to that theme and its inheritance chain. Do not use Luma RequireJS/Knockout conventions for Hyva work.
 
 For every request to create a new Magento module, call the \`mage2gen_generate_module\` tool to create the initial module scaffolding before writing custom files. The tool uses Mage2Gen at ${mage2genPath} and requires Python 3; it generates only into the selected Magento project, then inspect its output and adapt it to the task. Do not hand-create standard module boilerplate when Mage2Gen can create it. Skip Mage2Gen only when it cannot represent the requested module, and state the concrete reason before proceeding manually. Do not use it for a small targeted edit to an existing module.

package/dist/integrations/pi/context.js

@@ -1,4 +1,4 @@
-import { refreshStatus } from "#app/status";
+import { refreshStatus, setInitializingStatus } from "#app/status";
 import { merchantDuoSystemPrompt } from "#app/system-prompt";
 import { discoverTesting } from "#testing/index";
 import { discoverMagerun2 } from "#features/magerun2/index";
@@ -7,6 +7,7 @@ import { runtime, sessionEvents } from "#integrations/pi/session";
 export default function context(pi) {
     pi.on("session_start", async (_event, ctx) => {
         runtime.resetInjection();
+        setInitializingStatus(ctx);
         const state = await runtime.boot(ctx.cwd);
         if (state.environmentStatus === "stopped") {
             refreshStatus(ctx, state);

package/dist/integrations/pi/workspace.d.ts

@@ -2,4 +2,20 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { EnvironmentBackend } from "#environments/backend";
 /** Replaces Pi's native workspace tools with selected-environment operations. */
 export default function workspace(pi: ExtensionAPI): void;
+type SearchParameters = {
+    pattern: string;
+    glob?: string;
+    ignoreCase?: boolean;
+    literal?: boolean;
+    context?: number;
+    limit?: number;
+};
+/**
+ * Search the selected backend without making its runtime image depend on ripgrep:
+ * use rg when present, otherwise enumerate regular files and pass them to grep.
+ */
+export declare function searchCommand(params: SearchParameters, path: string): string;
 export declare function workspacePath(backend: EnvironmentBackend, cwd: string, candidate: string): string;
+/** Return only a declared MerchantDuo skill asset; project files remain environment-routed. */
+export declare function packagedSkillPath(candidate: string): string | undefined;
+export {};

package/dist/integrations/pi/workspace.js

@@ -1,16 +1,34 @@
+import { access as hostAccess, readFile as hostReadFile } from "node:fs/promises";
 import { relative, resolve } from "node:path";
 import { Type } from "typebox";
 import { createEditToolDefinition, createReadToolDefinition, createWriteToolDefinition, } from "@earendil-works/pi-coding-agent";
 import { runtime } from "#integrations/pi/session";
+import { packagePath } from "#shared/package-paths";
 const shell = (value) => `'${value.replace(/'/g, "'\\''")}'`;
 const result = (value) => ({ content: [{ type: "text", text: value }], details: {} });
+const packageSkillRoots = [
+    packagePath("skills"),
+    packagePath("vendor", "hyva-ai-tools", "skills"),
+];
 /** Replaces Pi's native workspace tools with selected-environment operations. */
 export default function workspace(pi) {
     registerFileTools(pi);
     pi.registerTool({ name: "bash", label: "bash", description: "Run a shell command in the selected MerchantDuo environment.", parameters: Type.Object({ command: Type.String(), timeout: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const output = await state.backend.run(["sh", "-lc", params.command], { signal, timeoutMs: params.timeout }); return result(`${output.stdout}${output.stderr}`); } });
     pi.registerTool({ name: "ls", label: "ls", description: "List a selected-environment directory.", parameters: Type.Object({ path: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const output = await state.backend.run(["sh", "-lc", `find ${shell(path)} -mindepth 1 -maxdepth 1 -printf '%f\\n' | head -n ${Math.max(1, Math.min(params.limit ?? 200, 1000))}`], { signal }); return result(output.stdout || output.stderr); } });
     pi.registerTool({ name: "find", label: "find", description: "Find files in the selected MerchantDuo environment.", parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const limit = Math.max(1, Math.min(params.limit ?? 1000, 5000)); const output = await state.backend.run(["sh", "-lc", `find ${shell(path)} -path '*/node_modules/*' -prune -o -path '*/.git/*' -prune -o -name ${shell(params.pattern)} -print | head -n ${limit}`], { signal }); return result(output.stdout || output.stderr); } });
-    pi.registerTool({ name: "grep", label: "grep", description: "Search text using ripgrep in the selected MerchantDuo environment.", parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()), glob: Type.Optional(Type.String()), ignoreCase: Type.Optional(Type.Boolean()), literal: Type.Optional(Type.Boolean()), context: Type.Optional(Type.Number()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const limit = Math.max(1, Math.min(params.limit ?? 100, 1000)); const flags = ["--line-number", "--color=never", `--max-count=${limit}`, params.ignoreCase ? "--ignore-case" : "", params.literal ? "--fixed-strings" : "", params.context ? `--context=${Math.min(params.context, 20)}` : "", params.glob ? `--glob ${shell(params.glob)}` : ""].filter(Boolean).join(" "); const output = await state.backend.run(["sh", "-lc", `rg ${flags} -- ${shell(params.pattern)} ${shell(path)}`], { signal }); return result(output.stdout || output.stderr); } });
+    pi.registerTool({ name: "grep", label: "grep", description: "Search text with ripgrep or a backend-local grep fallback in the selected MerchantDuo environment.", parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()), glob: Type.Optional(Type.String()), ignoreCase: Type.Optional(Type.Boolean()), literal: Type.Optional(Type.Boolean()), context: Type.Optional(Type.Number()), limit: Type.Optional(Type.Number()) }), async execute(_id, params, signal, _update, ctx) { const state = await runtime.boot(ctx.cwd); const path = workspacePath(state.backend, ctx.cwd, params.path ?? "."); const output = await state.backend.run(["sh", "-lc", searchCommand(params, path)], { signal }); return result(output.stdout || output.stderr); } });
+}
+/**
+ * Search the selected backend without making its runtime image depend on ripgrep:
+ * use rg when present, otherwise enumerate regular files and pass them to grep.
+ */
+export function searchCommand(params, path) {
+    const limit = Math.max(1, Math.min(params.limit ?? 100, 1000));
+    const context = params.context ? Math.min(params.context, 20) : undefined;
+    const rgFlags = ["--line-number", "--color=never", `--max-count=${limit}`, params.ignoreCase ? "--ignore-case" : "", params.literal ? "--fixed-strings" : "", context ? `--context=${context}` : "", params.glob ? `--glob ${shell(params.glob)}` : ""].filter(Boolean).join(" ");
+    const grepFlags = ["-n", params.ignoreCase ? "-i" : "", params.literal ? "-F" : "", context ? `-C ${context}` : ""].filter(Boolean).join(" ");
+    const glob = params.glob ? `-name ${shell(params.glob)} ` : "";
+    return `if command -v rg >/dev/null 2>&1; then rg ${rgFlags} -- ${shell(params.pattern)} ${shell(path)}; else find ${shell(path)} \\( -path '*/node_modules/*' -o -path '*/.git/*' \\) -prune -o -type f ${glob}-exec grep ${grepFlags} -- ${shell(params.pattern)} {} + 2>/dev/null | head -n ${limit}; fi`;
 }
 function registerFileTools(pi) {
     const localRead = createReadToolDefinition(process.cwd());
@@ -21,13 +39,33 @@ function registerFileTools(pi) {
     pi.registerTool({ ...localEdit, async execute(id, params, signal, update, ctx) { const state = await runtime.boot(ctx.cwd); return createEditToolDefinition(ctx.cwd, { operations: fileOps(state.backend, ctx.cwd) }).execute(id, params, signal, update, ctx); } });
 }
 function fileOps(backend, cwd) {
-    const readFile = async (path) => { const target = workspacePath(backend, cwd, path); const response = await backend.run(["sh", "-lc", `base64 < ${shell(target)}`]); if (response.exitCode)
-        throw new Error(response.stderr || "Cannot read file"); return Buffer.from(response.stdout.replace(/\s/g, ""), "base64"); };
+    const readFile = async (path) => {
+        const skillPath = packagedSkillPath(path);
+        if (skillPath)
+            return hostReadFile(skillPath);
+        const target = workspacePath(backend, cwd, path);
+        const response = await backend.run(["sh", "-lc", `base64 < ${shell(target)}`]);
+        if (response.exitCode)
+            throw new Error(response.stderr || "Cannot read file");
+        return Buffer.from(response.stdout.replace(/\s/g, ""), "base64");
+    };
     const writeFile = async (path, content) => { const target = workspacePath(backend, cwd, path); const response = await backend.run(["sh", "-lc", `base64 -d > ${shell(target)}`], { input: Buffer.from(content).toString("base64") }); if (response.exitCode)
         throw new Error(response.stderr || "Cannot write file"); };
-    return { readFile, writeFile, access: async (path) => { const response = await backend.run(["sh", "-lc", `test -r ${shell(workspacePath(backend, cwd, path))}`]); if (response.exitCode)
+    return { readFile, writeFile, access: async (path) => { const skillPath = packagedSkillPath(path); if (skillPath) {
+            await hostAccess(skillPath);
+            return;
+        } const response = await backend.run(["sh", "-lc", `test -r ${shell(workspacePath(backend, cwd, path))}`]); if (response.exitCode)
             throw new Error("Path is inaccessible"); }, mkdir: async (path) => { const response = await backend.run(["mkdir", "-p", workspacePath(backend, cwd, path)]); if (response.exitCode)
             throw new Error(response.stderr || "Cannot create directory"); } };
 }
 export function workspacePath(backend, cwd, candidate) { const full = resolve(cwd, candidate); const value = relative(resolve(cwd), full); if (value === ".." || value.startsWith("../"))
     throw new Error(`Path escapes workspace: ${candidate}`); return backend.path(value); }
+/** Return only a declared MerchantDuo skill asset; project files remain environment-routed. */
+export function packagedSkillPath(candidate) {
+    const full = resolve(candidate);
+    return packageSkillRoots.some((root) => contains(root, full)) ? full : undefined;
+}
+function contains(root, candidate) {
+    const value = relative(root, candidate);
+    return value === "" || (value !== ".." && !value.startsWith("../"));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merchantduo/code",
-  "version": "0.2.0-beta.5",
+  "version": "0.3.0-beta.0",
   "private": false,
   "description": "Magento-native Pi-based Coding Agent",
   "type": "module",
@@ -48,7 +48,9 @@
       "./dist/integrations/pi/mage2gen.js",
       "./dist/integrations/pi/workflows.js",
       "./dist/integrations/pi/magerun2.js",
-      "./dist/integrations/pi/testing.js"
+      "./dist/integrations/pi/testing.js",
+      "./node_modules/pi-web-access",
+      "./node_modules/pi-goal"
     ],
     "skills": [
       "./skills",
@@ -58,6 +60,8 @@
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.84.1",
     "@modelcontextprotocol/client": "2.0.0",
+    "pi-goal": "0.1.7",
+    "pi-web-access": "0.22.0",
     "typebox": "1.3.7",
     "yaml": "^2.8.1",
     "zod": "^3.24.4"