@w32191/just-loop 0.1.0 → 0.1.1

package/dist/src/plugin/command-definitions.d.ts

@@ -0,0 +1,6 @@
+export type CommandDefinition = {
+    name: string;
+    description: string;
+    template: string;
+};
+export declare function getBuiltinCommands(): Record<string, CommandDefinition>;

package/dist/src/plugin/command-definitions.js

@@ -0,0 +1,59 @@
+const RALPH_LOOP_TEMPLATE = `You are starting a Ralph Loop - a self-referential development loop that runs until task completion.
+
+## How Ralph Loop Works
+
+1. You will work on the task continuously
+2. When you believe the task is FULLY complete, output: \`<promise>{{COMPLETION_PROMISE}}</promise>\`
+3. If you don't output the promise, the loop will automatically inject another prompt to continue
+4. Maximum iterations: Configurable (default 100)
+
+## Rules
+
+- Focus on completing the task fully, not partially
+- Don't output the completion promise until the task is truly done
+- Each iteration should make meaningful progress toward the goal
+- If stuck, try different approaches
+- Use todos to track your progress
+
+## Exit Conditions
+
+1. **Completion**: Output your completion promise tag when fully complete
+2. **Max Iterations**: Loop stops automatically at limit
+3. **Cancel**: User runs \`/cancel-ralph\` command
+
+## Your Task
+
+Parse the arguments below and begin working on the task. The format is:
+\`"task description" [--completion-promise=TEXT] [--max-iterations=N] [--strategy=reset|continue]\`
+
+Default completion promise is "DONE" and default max iterations is 100.`;
+const CANCEL_RALPH_TEMPLATE = `Cancel the currently active Ralph Loop.
+
+This will:
+1. Stop the loop from continuing
+2. Clear the loop state file
+3. Allow the session to end normally
+
+Check if a loop is active and cancel it. Inform the user of the result.`;
+export function getBuiltinCommands() {
+    return {
+        "ralph-loop": {
+            name: "ralph-loop",
+            description: "(builtin) Start self-referential development loop until completion",
+            template: `<command-instruction>
+${RALPH_LOOP_TEMPLATE}
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+        },
+        "cancel-ralph": {
+            name: "cancel-ralph",
+            description: "(builtin) Cancel active Ralph Loop",
+            template: `<command-instruction>
+${CANCEL_RALPH_TEMPLATE}
+</command-instruction>`,
+        },
+    };
+}

package/dist/src/plugin/config-handler.d.ts

@@ -0,0 +1 @@
+export declare function handleConfig(input: Record<string, unknown>): Promise<void>;

package/dist/src/plugin/config-handler.js

@@ -0,0 +1,10 @@
+import { getBuiltinCommands } from "./command-definitions.js";
+export async function handleConfig(input) {
+    const existingCommands = input.command && typeof input.command === "object"
+        ? input.command
+        : {};
+    input.command = {
+        ...getBuiltinCommands(),
+        ...existingCommands,
+    };
+}

package/dist/src/plugin/create-plugin.d.ts

@@ -25,9 +25,21 @@ type ChatMessageOutput = {
 type EventInput = {
     event?: unknown;
 };
+type ToolExecuteBeforeInput = {
+    tool?: unknown;
+    sessionID?: unknown;
+    callID?: unknown;
+};
+type ToolExecuteBeforeOutput = {
+    args?: {
+        name?: unknown;
+    };
+};
 export type PluginHooks = {
     "chat.message": (input: ChatMessageInput, output: ChatMessageOutput) => Promise<void>;
     event: (input: EventInput) => Promise<void>;
+    config: (input: Record<string, unknown>) => Promise<void>;
+    "tool.execute.before": (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => Promise<void>;
 };
 export declare function createPlugin(ctx?: PluginInput, deps?: CreatePluginDeps): Promise<PluginHooks>;
 export {};

package/dist/src/plugin/create-plugin.js

@@ -1,7 +1,8 @@
 import { createOpenCodeHostAdapter } from "../host-adapter/opencode-host-adapter.js";
 import { createLoopCore } from "../ralph-loop/loop-core.js";
-import { handleChatMessage } from "./chat-message-handler.js";
+import { handleConfig } from "./config-handler.js";
 import { handleEvent } from "./event-handler.js";
+import { handleToolExecuteBefore } from "./tool-execute-before-handler.js";
 function extractSessionID(input) {
     if (typeof input.sessionID === "string")
         return input.sessionID;
@@ -37,16 +38,22 @@ export async function createPlugin(ctx, deps = {}) {
     });
     const core = createCore({ rootDir: ctx.directory, adapter });
     return {
+        config: async (input) => {
+            await handleConfig(input);
+        },
         "chat.message": async (input, output) => {
             const sessionID = extractSessionID(input);
             if (!sessionID)
                 return;
-            await handleChatMessage(extractChatText(output.parts), core, sessionID);
+            extractChatText(output.parts);
         },
         event: async (input) => {
             if (!input.event)
                 return;
             await handleEvent(input.event, core);
         },
+        "tool.execute.before": async (input, output) => {
+            await handleToolExecuteBefore(input, output, core);
+        },
     };
 }

package/dist/src/plugin/tool-execute-before-handler.d.ts

@@ -0,0 +1,18 @@
+type LoopCore = {
+    startLoop: (sessionID: string, prompt: string, options: {
+        maxIterations?: number;
+        completionPromise?: string;
+    }) => Promise<unknown>;
+    cancelLoop: (sessionID: string) => Promise<unknown>;
+};
+type ToolExecuteBeforeInput = {
+    tool?: unknown;
+    sessionID?: unknown;
+};
+type ToolExecuteBeforeOutput = {
+    args?: {
+        name?: unknown;
+    };
+};
+export declare function handleToolExecuteBefore(input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput, core: LoopCore): Promise<void>;
+export {};

package/dist/src/plugin/tool-execute-before-handler.js

@@ -0,0 +1,23 @@
+import { parseRalphLoopCommand } from "../commands/parse-ralph-loop-command.js";
+function normalizeCommandName(name) {
+    return name.startsWith("/") ? name : `/${name}`;
+}
+export async function handleToolExecuteBefore(input, output, core) {
+    if (input.tool !== "skill")
+        return;
+    if (typeof input.sessionID !== "string")
+        return;
+    if (typeof output.args?.name !== "string")
+        return;
+    const command = parseRalphLoopCommand(normalizeCommandName(output.args.name));
+    if (!command)
+        return;
+    if (command.kind === "cancel") {
+        await core.cancelLoop(input.sessionID);
+        return;
+    }
+    await core.startLoop(input.sessionID, command.prompt, {
+        maxIterations: command.maxIterations,
+        completionPromise: command.completionPromise,
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@w32191/just-loop",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "OpenCode plugin package for just-loop.",
   "license": "MIT",
   "main": "./dist/src/index.js",
@@ -12,7 +12,11 @@
       "import": "./dist/src/index.js"
     }
   },
-  "files": ["dist/", "README.md", "LICENSE"],
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
   "publishConfig": {
     "access": "public"
   },