jorgex-stack 1.9.1 → 1.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jorgex-stack",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "Harness multi-agente portable: instala la config JorgeX (agentes, skills, hooks, Engram, MCPs) en Claude Code, Codex CLI, OpenCode y Pi",
   "type": "module",
   "license": "MIT",

package/stack/plugins/opencode/worktree.ts

@@ -16,6 +16,32 @@ interface ScriptResult {
   scriptPath: string;
 }
 
+const logToOpenCode = async (
+  client: unknown,
+  level: "warn" | "error",
+  message: string,
+  extra?: unknown,
+) => {
+  if (typeof client !== "object" || client === null) return;
+  const app = (client as { app?: unknown }).app;
+  if (typeof app !== "object" || app === null) return;
+  const log = (app as { log?: unknown }).log;
+  if (typeof log !== "function") return;
+
+  const safeExtra =
+    extra instanceof Error
+      ? { message: extra.message, stack: extra.stack }
+      : extra;
+
+  try {
+    await log.call(app, {
+      body: { service: "hooks", level, message, extra: safeExtra },
+    });
+  } catch {
+    // Logging must not break the OpenCode TUI hook.
+  }
+};
+
 const isAbsolutePath = (value: string) =>
   /^[a-zA-Z]:[\\/]/.test(value) || value.startsWith("/");
 
@@ -43,6 +69,22 @@ const resolveProjectPath = (directory: string, target?: string) => {
 const isPlainObject = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value);
 
+const validateConfig = (config: Record<string, unknown>) => {
+  for (const field of ["setupScript", "docsReminderScript", "pathContains"]) {
+    if (field in config && typeof config[field] !== "string") {
+      return `Worktree config field "${field}" must be a string.`;
+    }
+  }
+
+  if (
+    "reminderLines" in config &&
+    (!Array.isArray(config.reminderLines) ||
+      !config.reminderLines.every((line) => typeof line === "string"))
+  ) {
+    return 'Worktree config field "reminderLines" must be an array of strings.';
+  }
+};
+
 const getPayloadWorktreePath = (payload: unknown) => {
   if (!isPlainObject(payload)) return undefined;
 
@@ -142,15 +184,14 @@ const runScript = async (
   }
 
   if (!command) {
-    await client.app.log({
-      body: {
-        service: "hooks",
-        level: "warn",
-        message: "Unsupported worktree hook script extension",
-        extra: { script, scriptPath },
-      },
-    });
-    return { exitCode: 0, stdout: "", stderr: "", script, scriptPath };
+    const stderr = `Unsupported worktree hook script extension for ${scriptPath}.`;
+    await logToOpenCode(
+      client,
+      "warn",
+      "Unsupported worktree hook script extension",
+      { script, scriptPath },
+    );
+    return { exitCode: 1, stdout: "", stderr, script, scriptPath };
   }
 
   try {
@@ -173,35 +214,26 @@ const runScript = async (
     ]);
 
     if (exitCode !== 0) {
-      await client.app.log({
-        body: {
-          service: "hooks",
-          level: "error",
-          message: "Worktree hook script execution failed",
-          extra: {
-            script,
-            scriptPath,
-            exitCode,
-            stderr: stderr.trim(),
-            stdout: stdout.trim(),
-          },
+      await logToOpenCode(
+        client,
+        "error",
+        "Worktree hook script execution failed",
+        {
+          script,
+          scriptPath,
+          exitCode,
+          stderr: stderr.trim(),
+          stdout: stdout.trim(),
         },
-      });
+      );
     }
 
     return { exitCode, stdout, stderr, script, scriptPath };
   } catch (error) {
-    await client.app.log({
-      body: {
-        service: "hooks",
-        level: "error",
-        message: "Worktree hook script execution failed",
-        extra: {
-          script,
-          scriptPath,
-          error: error instanceof Error ? error.message : String(error),
-        },
-      },
+    await logToOpenCode(client, "error", "Worktree hook script execution failed", {
+      script,
+      scriptPath,
+      error: error instanceof Error ? error.message : String(error),
     });
     return {
       exitCode: 1,
@@ -285,28 +317,67 @@ const getCommandCwd = (args: Record<string, unknown>, directory: string) => {
 const replaceToken = (value: string, token: string, replacement: string) =>
   value.split(token).join(replacement);
 
+const isMissingFileError = (error: unknown) => {
+  const code =
+    typeof error === "object" && error !== null && "code" in error
+      ? (error as { code?: unknown }).code
+      : undefined;
+  return (
+    code === "ENOENT" ||
+    (error instanceof Error && /not found|no such file/i.test(error.message))
+  );
+};
+
 export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
   let config: WorktreePluginConfig = {
-    setupScript: "scripts/setup-worktree.ps1",
     pathContains: "worktrees/",
     reminderLines: [],
   };
+  let configError: string | undefined;
 
   try {
     const configPath = `${directory}/.opencode/worktree.json`;
-    const content = await (globalThis as any).Bun.file(configPath).text();
-    config = {
-      ...config,
-      ...JSON.parse(content),
-    };
-  } catch {
-    // Optional project config
+    const configFile = (globalThis as any).Bun.file(configPath);
+    if (
+      typeof configFile.exists === "function" &&
+      !(await configFile.exists())
+    ) {
+      // Optional project config.
+    } else {
+      const parsed = JSON.parse(await configFile.text()) as unknown;
+      if (!isPlainObject(parsed)) {
+        configError = "Worktree config must be a JSON object.";
+      } else {
+        configError = validateConfig(parsed);
+        if (!configError) {
+          config = { ...config, ...(parsed as WorktreePluginConfig) };
+        }
+      }
+    }
+  } catch (error) {
+    if (!isMissingFileError(error)) {
+      const couldNotParse = error instanceof SyntaxError;
+      configError = couldNotParse
+        ? "Worktree config could not be parsed as JSON."
+        : "Worktree config could not be read.";
+      await logToOpenCode(
+        client,
+        "warn",
+        couldNotParse
+          ? "Worktree config could not be parsed"
+          : "Worktree config could not be read",
+        error,
+      );
+    }
   }
 
   return {
     "tool.execute.after": async (input: any, output: any) => {
       try {
         const tool = (input.tool || "").toLowerCase();
+        const args = input.args || {};
+        const command = args.command || "";
+
         const payload = {
           event: "tool.execute.after",
           directory,
@@ -315,6 +386,11 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
         };
 
         if (tool === "enterworktree") {
+          if (configError) {
+            appendToolOutput(output, [configError]);
+            return;
+          }
+
           const docsReminderScript = resolveProjectPath(
             directory,
             config.docsReminderScript,
@@ -337,8 +413,6 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
 
         if (tool !== "bash") return;
 
-        const args = input.args || {};
-        const command = args.command || "";
         const commandLower = command.toLowerCase();
         const pathContains = toSlashes(
           config.pathContains || "worktrees/",
@@ -366,12 +440,24 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
           `worktrees/${worktreeName}`,
         );
 
-        if (!samePath(absoluteWorktreePath, expectedWorktreePath)) {
+        const isCanonicalPath = samePath(
+          absoluteWorktreePath,
+          expectedWorktreePath,
+        );
+        if (!isCanonicalPath) {
           appendToolOutput(output, [
             `Worktree path is not canonical: ${absoluteWorktreePath}`,
             `Use the project-local path instead: ${expectedWorktreePath}`,
             "Canonical rule: <project-root>/worktrees/<canonical-name> or <project-root>/worktrees/<canonical-name>-prNN.",
           ]);
+        }
+
+        if (configError) {
+          appendToolOutput(output, [configError]);
+          return;
+        }
+
+        if (!isCanonicalPath) {
           return;
         }
 
@@ -430,15 +516,16 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
           appendToolOutput(output, [banner]);
         }
       } catch (error) {
-        await client.app.log({
-          body: {
-            service: "hooks",
-            level: "error",
-            message: "Worktree plugin execution failed",
-            extra: {
-              error: error instanceof Error ? error.message : String(error),
-            },
-          },
+        const details = truncateMessage(
+          error instanceof Error ? error.message : String(error),
+        );
+        appendToolOutput(output, [
+          "Worktree plugin could not process this worktree command.",
+          "Run `git rev-parse --show-toplevel` from the project root and retry.",
+          ...(details ? [`Details: ${details}`] : []),
+        ]);
+        await logToOpenCode(client, "error", "Worktree plugin execution failed", {
+          error: error instanceof Error ? error.message : String(error),
         });
       }
     },