@w32191/just-loop 0.1.6 → 0.1.8

package/README.md

@@ -6,23 +6,18 @@ OpenCode plugin package for just-loop.
 
 - Node 20+
 
-## Install
-
-```bash
-npm install @w32191/just-loop
-```
-
 ## Usage
 
-Put this in your OpenCode plugin entry or config file:
-
-```ts
-import justLoop from "@w32191/just-loop"
+在 `opencode.json` 的 `plugin` 欄位加入 plugin 名稱即可載入：
 
-export default justLoop
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@w32191/just-loop"]
+}
 ```
 
-This package is intended for OpenCode plugin usage.
+依官方文件，`opencode.json` 放在專案根目錄（專案設定）或 `~/.config/opencode/opencode.json`（全域設定）皆可，OpenCode 會在啟動時自動安裝與載入 npm 套件型 plugin。
 
 ## Publishing notes
 

package/dist/src/host-adapter/opencode-host-adapter.js

@@ -76,5 +76,8 @@ export function createOpenCodeHostAdapter(ctx) {
                 throw error;
             }
         },
+        async showToast(toast) {
+            await ctx.client.tui?.showToast?.({ body: toast });
+        },
     };
 }

package/dist/src/host-adapter/types.d.ts

@@ -8,6 +8,12 @@ export interface HostAdapter {
     prompt(sessionID: string, text: string): Promise<void>;
     abortSession(sessionID: string): Promise<void>;
     sessionExists(sessionID: string): Promise<boolean>;
+    showToast?(toast: {
+        title: string;
+        message: string;
+        variant?: "info" | "warning" | "error" | "success";
+        duration?: number;
+    }): Promise<void>;
 }
 export type OpenCodeHostAdapterContext = {
     directory: string;
@@ -38,5 +44,15 @@ export type OpenCodeHostAdapterContext = {
                 directory?: string;
             }) => Promise<unknown>;
         };
+        tui?: {
+            showToast?: (input: {
+                body: {
+                    title: string;
+                    message: string;
+                    variant?: "info" | "warning" | "error" | "success";
+                    duration?: number;
+                };
+            }) => Promise<unknown>;
+        };
     };
 };

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

@@ -38,12 +38,20 @@ export async function createPlugin(ctx, deps = {}) {
                 prompt: async ({ sessionID, directory, parts }) => ctx.client.session.prompt({ path: { id: sessionID }, body: { parts }, query: { directory } }),
                 abort: async ({ sessionID }) => ctx.client.session.abort({ path: { id: sessionID } }),
             },
+            tui: ctx.client.tui?.showToast
+                ? { showToast: async ({ body }) => ctx.client.tui?.showToast?.({ body: body }) }
+                : undefined,
         },
     });
     const core = createCore({
         rootDir: ctx.directory,
         adapter,
         getConfig: () => resolvedConfig,
+        wait: async (ms) => {
+            await new Promise((resolve) => {
+                setTimeout(resolve, ms);
+            });
+        },
     });
     return {
         config: async (input) => {

package/dist/src/plugin/tui-command-execute-handler.js

@@ -1,10 +1,7 @@
 function hasInterruptCommand(input) {
     if (!input || typeof input !== "object")
         return false;
-    const properties = input.properties;
-    if (!properties || typeof properties !== "object")
-        return false;
-    return properties.command === "session.interrupt";
+    return input.command === "session.interrupt";
 }
 export async function handleTuiCommandExecute(input, core) {
     if (!hasInterruptCommand(input))

package/dist/src/ralph-loop/constants.d.ts

@@ -2,3 +2,5 @@ export declare const DEFAULT_STATE_PATH = ".loop/ralph-loop.local.md";
 export declare const DEFAULT_COMPLETION_PROMISE = "<promise>DONE</promise>";
 export declare const DEFAULT_MAX_ITERATIONS_FALLBACK = 100;
 export declare const DEFAULT_STRATEGY = "continue";
+export declare const CONTINUATION_COUNTDOWN_SECONDS = 10;
+export declare const CONTINUATION_COUNTDOWN_STEP_MS = 1000;

package/dist/src/ralph-loop/constants.js

@@ -2,3 +2,5 @@ export const DEFAULT_STATE_PATH = ".loop/ralph-loop.local.md";
 export const DEFAULT_COMPLETION_PROMISE = "<promise>DONE</promise>";
 export const DEFAULT_MAX_ITERATIONS_FALLBACK = 100;
 export const DEFAULT_STRATEGY = "continue";
+export const CONTINUATION_COUNTDOWN_SECONDS = 10;
+export const CONTINUATION_COUNTDOWN_STEP_MS = 1000;

package/dist/src/ralph-loop/loop-core.d.ts

@@ -16,6 +16,7 @@ export type CreateLoopCoreDeps = {
     rootDir: string;
     adapter: HostAdapter;
     getConfig?: () => RalphLoopRuntimeConfig;
+    wait?: (ms: number) => Promise<void>;
 };
 export type StartLoopOptions = {
     maxIterations?: number;

package/dist/src/ralph-loop/loop-core.js

@@ -1,4 +1,4 @@
-import { DEFAULT_COMPLETION_PROMISE, DEFAULT_MAX_ITERATIONS_FALLBACK, DEFAULT_STRATEGY } from "./constants.js";
+import { CONTINUATION_COUNTDOWN_SECONDS, CONTINUATION_COUNTDOWN_STEP_MS, DEFAULT_COMPLETION_PROMISE, DEFAULT_MAX_ITERATIONS_FALLBACK, DEFAULT_STRATEGY, } from "./constants.js";
 import { buildContinuationPrompt } from "./continuation-prompt.js";
 import { detectCompletion } from "./completion-detector.js";
 import { clearState, readState, writeState } from "./state-store.js";
@@ -12,6 +12,16 @@ export function createLoopCore(deps) {
         defaultStrategy: DEFAULT_STRATEGY,
     };
     const getToken = (state) => state.incarnation_token ?? state.started_at;
+    const wait = deps.wait;
+    function showToast(title, message, variant = "info") {
+        void deps.adapter.showToast?.({ title, message, variant, duration: 1000 }).catch(() => { });
+    }
+    async function readCurrentState(sessionID, token) {
+        const state = await readState(deps.rootDir);
+        if (!state || !state.active || state.session_id !== sessionID || getToken(state) !== token)
+            return null;
+        return state;
+    }
     const runStateMutation = async (mutation) => {
         const run = stateMutationQueue.then(mutation, mutation);
         stateMutationQueue = run.then(() => undefined, () => undefined);
@@ -63,6 +73,8 @@ export function createLoopCore(deps) {
                     const state = await readState(deps.rootDir);
                     if (!state || !state.active)
                         return;
+                    if (state.pending_continuation?.cancelled)
+                        return;
                     const observedSessionID = state.session_id;
                     const observedToken = getToken(state);
                     // active-loop-scoped only: the host interrupt hook does not provide sessionID,
@@ -74,6 +86,23 @@ export function createLoopCore(deps) {
                         getToken(currentState) !== observedToken) {
                         return;
                     }
+                    if (currentState.pending_continuation) {
+                        if (currentState.pending_continuation.dispatch_token) {
+                            await writeState(deps.rootDir, {
+                                ...currentState,
+                                skip_next_continuation: true,
+                            });
+                            return;
+                        }
+                        if (currentState.pending_continuation.cancelled)
+                            return;
+                        await writeState(deps.rootDir, {
+                            ...currentState,
+                            pending_continuation: { ...currentState.pending_continuation, cancelled: true },
+                        });
+                        showToast("Ralph Loop", "Cancelled the pending Ralph Loop continuation.", "info");
+                        return;
+                    }
                     await writeState(deps.rootDir, {
                         ...currentState,
                         skip_next_continuation: true,
@@ -124,20 +153,12 @@ export function createLoopCore(deps) {
                     .some((message) => message.role === "assistant");
                 if (!hasNewAssistantMessages)
                     return;
-                const liveState = await readState(deps.rootDir);
-                if (!liveState ||
-                    !liveState.active ||
-                    liveState.session_id !== event.sessionID ||
-                    getToken(liveState) !== incarnationToken) {
+                const liveState = await readCurrentState(event.sessionID, incarnationToken);
+                if (!liveState)
                     return;
-                }
-                const continuationState = await readState(deps.rootDir);
-                if (!continuationState ||
-                    !continuationState.active ||
-                    continuationState.session_id !== event.sessionID ||
-                    getToken(continuationState) !== incarnationToken) {
+                const continuationState = await readCurrentState(event.sessionID, incarnationToken);
+                if (!continuationState)
                     return;
-                }
                 if (detectCompletion(messages, continuationState.completion_promise, continuationState.message_count_at_start)) {
                     await runStateMutation(async () => {
                         const currentState = await readState(deps.rootDir);
@@ -187,12 +208,139 @@ export function createLoopCore(deps) {
                     });
                     return;
                 }
-                await deps.adapter.prompt(event.sessionID, buildContinuationPrompt({
-                    iteration: nextIteration,
-                    prompt: continuationState.prompt,
-                    completionPromise: continuationState.completion_promise,
-                    maxIterations: continuationState.max_iterations,
-                }));
+                if (wait) {
+                    await runStateMutation(async () => {
+                        const currentState = await readCurrentState(event.sessionID, incarnationToken);
+                        if (!currentState || currentState.pending_continuation)
+                            return;
+                        await writeState(deps.rootDir, {
+                            ...currentState,
+                            pending_continuation: {
+                                started_at: new Date().toISOString(),
+                                countdown_seconds_remaining: CONTINUATION_COUNTDOWN_SECONDS,
+                            },
+                        });
+                    });
+                    showToast("Ralph Loop", `Injecting next continuation in ${CONTINUATION_COUNTDOWN_SECONDS}s. Use interrupt to cancel once.`, "warning");
+                    for (let remaining = CONTINUATION_COUNTDOWN_SECONDS; remaining > 0; remaining -= 1) {
+                        await wait(CONTINUATION_COUNTDOWN_STEP_MS);
+                        const currentState = await readCurrentState(event.sessionID, incarnationToken);
+                        if (!currentState?.pending_continuation)
+                            return;
+                        if (currentState.pending_continuation.cancelled) {
+                            await runStateMutation(async () => {
+                                const latest = await readCurrentState(event.sessionID, incarnationToken);
+                                if (!latest?.pending_continuation?.cancelled)
+                                    return;
+                                const nextState = {
+                                    ...latest,
+                                    last_message_count_processed: batchMessageCount,
+                                };
+                                delete nextState.pending_continuation;
+                                await writeState(deps.rootDir, nextState);
+                            });
+                            return;
+                        }
+                        await runStateMutation(async () => {
+                            const latest = await readCurrentState(event.sessionID, incarnationToken);
+                            if (!latest?.pending_continuation || latest.pending_continuation.cancelled)
+                                return;
+                            await writeState(deps.rootDir, {
+                                ...latest,
+                                pending_continuation: {
+                                    ...latest.pending_continuation,
+                                    countdown_seconds_remaining: remaining - 1,
+                                },
+                            });
+                        });
+                        if (remaining > 1) {
+                            showToast("Ralph Loop", `Injecting next continuation in ${remaining - 1}s. Use interrupt to cancel once.`, "warning");
+                        }
+                    }
+                    const dispatchToken = randomUUID();
+                    const continuationPrompt = buildContinuationPrompt({
+                        iteration: nextIteration,
+                        prompt: continuationState.prompt,
+                        completionPromise: continuationState.completion_promise,
+                        maxIterations: continuationState.max_iterations,
+                    });
+                    const dispatchResult = await runStateMutation(async () => {
+                        const currentState = await readCurrentState(event.sessionID, incarnationToken);
+                        if (!currentState?.pending_continuation)
+                            return { kind: "aborted" };
+                        if (currentState.pending_continuation.cancelled) {
+                            const nextState = {
+                                ...currentState,
+                                last_message_count_processed: batchMessageCount,
+                            };
+                            delete nextState.pending_continuation;
+                            await writeState(deps.rootDir, nextState);
+                            return { kind: "cancelled" };
+                        }
+                        await writeState(deps.rootDir, {
+                            ...currentState,
+                            pending_continuation: {
+                                ...currentState.pending_continuation,
+                                countdown_seconds_remaining: 0,
+                                dispatch_token: dispatchToken,
+                            },
+                        });
+                    });
+                    if (dispatchResult?.kind === "aborted" || dispatchResult?.kind === "cancelled") {
+                        return;
+                    }
+                    try {
+                        await deps.adapter.prompt(event.sessionID, continuationPrompt);
+                    }
+                    catch (error) {
+                        await runStateMutation(async () => {
+                            const latest = await readCurrentState(event.sessionID, incarnationToken);
+                            if (latest?.pending_continuation?.dispatch_token !== dispatchToken)
+                                return;
+                            const nextState = { ...latest };
+                            delete nextState.pending_continuation;
+                            await writeState(deps.rootDir, nextState);
+                        });
+                        throw error;
+                    }
+                    await runStateMutation(async () => {
+                        const latest = await readCurrentState(event.sessionID, incarnationToken);
+                        if (!latest?.pending_continuation)
+                            return;
+                        if (latest.pending_continuation.dispatch_token !== dispatchToken)
+                            return;
+                        const nextState = {
+                            ...latest,
+                            iteration: nextIteration,
+                            last_message_count_processed: batchMessageCount,
+                        };
+                        delete nextState.pending_continuation;
+                        await writeState(deps.rootDir, nextState);
+                    });
+                }
+                if (wait) {
+                    showToast("Ralph Loop", "Injected Ralph Loop continuation.", "success");
+                    return;
+                }
+                try {
+                    await deps.adapter.prompt(event.sessionID, buildContinuationPrompt({
+                        iteration: nextIteration,
+                        prompt: continuationState.prompt,
+                        completionPromise: continuationState.completion_promise,
+                        maxIterations: continuationState.max_iterations,
+                    }));
+                }
+                catch (error) {
+                    await runStateMutation(async () => {
+                        const currentState = await readCurrentState(event.sessionID, incarnationToken);
+                        if (!currentState?.pending_continuation)
+                            return;
+                        const nextState = { ...currentState };
+                        delete nextState.pending_continuation;
+                        await writeState(deps.rootDir, nextState);
+                    });
+                    throw error;
+                }
                 await runStateMutation(async () => {
                     const currentState = await readState(deps.rootDir);
                     if (!currentState ||
@@ -208,6 +356,7 @@ export function createLoopCore(deps) {
                     };
                     await writeState(deps.rootDir, nextState);
                 });
+                showToast("Ralph Loop", "Injected Ralph Loop continuation.", "success");
             }
             finally {
                 const currentToken = inFlight.get(event.sessionID);

package/dist/src/ralph-loop/state-store.js

@@ -18,6 +18,15 @@ function isRalphLoopState(value) {
         typeof record.message_count_at_start === "number" &&
         (record.last_message_count_processed === undefined || typeof record.last_message_count_processed === "number") &&
         (record.skip_next_continuation === undefined || typeof record.skip_next_continuation === "boolean") &&
+        (record.pending_continuation === undefined ||
+            (typeof record.pending_continuation === "object" &&
+                record.pending_continuation !== null &&
+                typeof record.pending_continuation.started_at === "string" &&
+                typeof record.pending_continuation.countdown_seconds_remaining === "number" &&
+                (record.pending_continuation.cancelled === undefined ||
+                    typeof record.pending_continuation.cancelled === "boolean") &&
+                (record.pending_continuation.dispatch_token === undefined ||
+                    typeof record.pending_continuation.dispatch_token === "string"))) &&
         (record.incarnation_token === undefined || typeof record.incarnation_token === "string") &&
         typeof record.started_at === "string");
 }

package/dist/src/ralph-loop/types.d.ts

@@ -8,6 +8,12 @@ export type RalphLoopState = {
     message_count_at_start: number;
     last_message_count_processed?: number;
     skip_next_continuation?: boolean;
+    pending_continuation?: {
+        started_at: string;
+        countdown_seconds_remaining: number;
+        cancelled?: boolean;
+        dispatch_token?: string;
+    };
     incarnation_token?: string;
     started_at: string;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@w32191/just-loop",
   "type": "module",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "OpenCode plugin package for just-loop.",
   "license": "MIT",
   "repository": {