@tduyng/pi-goal 0.0.0-stage → 0.0.2

package/src/loop/index.ts

@@ -0,0 +1,198 @@
+import type { JsonValue } from '@earendil-works/pi-ai'
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import { Validator } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+import { MAX_INTERVAL_MS, paceLabel, parseLoopArgs, type LoopState } from './logic.js'
+
+const STATE_TYPE = 'loop'
+const DEFAULT_PROMPT =
+    'Run a maintenance check: review recent work and address anything stale, broken, or left half-finished.'
+const SELF_PACE_DELAY_MS = 250
+const RecordSchema = t.object({}, { additionalProperties: true })
+const isRecordSchema = new Validator(RecordSchema).isValidObject
+const LoopStateSchema = t.object({
+    prompt: t.string(),
+    intervalMs: t.union([t.null(), t.number({ exclusiveMinimum: 0, maximum: MAX_INTERVAL_MS })]),
+    iterations: t.integer({ minimum: 0 }),
+    createdAt: t.number(),
+    lastFiredAt: t.union([t.null(), t.number()])
+})
+const isLoopStateSchema = new Validator(LoopStateSchema).isValidObject
+
+function isJsonObject(value: unknown): value is Record<string, JsonValue> {
+    return isRecordSchema(value)
+}
+
+export function parseLoopState(value: JsonValue): LoopState | null {
+    return isLoopStateSchema(value) ? value : null
+}
+
+export default function loopExtension(pi: ExtensionAPI): void {
+    let loop: LoopState | null = null
+    let timer: ReturnType<typeof setTimeout> | null = null
+    let lastError: string | undefined
+
+    function clearTimer(): void {
+        if (timer) {
+            clearTimeout(timer)
+            timer = null
+        }
+    }
+
+    function persist(): void {
+        pi.appendEntry(STATE_TYPE, loop)
+    }
+
+    function updateStatus(ctx: ExtensionContext): void {
+        if (!ctx.hasUI) return
+        if (!loop) {
+            ctx.ui.setStatus('loop', undefined)
+            return
+        }
+        const theme = ctx.ui.theme
+        ctx.ui.setStatus('loop', theme.fg('accent', `Loop ${paceLabel(loop.intervalMs)} (${loop.iterations})`))
+    }
+
+    function fire(ctx: ExtensionContext): void {
+        if (!loop) return
+        loop.iterations += 1
+        loop.lastFiredAt = Date.now()
+        persist()
+        updateStatus(ctx)
+
+        if (!ctx.hasPendingMessages()) {
+            pi.sendUserMessage(loop.prompt, ctx.isIdle() ? undefined : { deliverAs: 'followUp' })
+        }
+
+        if (loop.intervalMs !== null) {
+            clearTimer()
+            timer = setTimeout(() => fireSafely(ctx), loop.intervalMs)
+        }
+    }
+
+    function fireSafely(ctx: ExtensionContext): void {
+        try {
+            fire(ctx)
+        } catch (error) {
+            clearTimer()
+            loop = null
+            try {
+                persist()
+                updateStatus(ctx)
+                ctx.ui.notify(`Loop stopped: ${error instanceof Error ? error.message : String(error)}`, 'warning')
+            } catch {}
+        }
+    }
+
+    function startLoop(ctx: ExtensionContext, prompt: string, intervalMs: number | null): void {
+        clearTimer()
+        const now = Date.now()
+        loop = { prompt: prompt || DEFAULT_PROMPT, intervalMs, iterations: 0, createdAt: now, lastFiredAt: null }
+        persist()
+        updateStatus(ctx)
+        ctx.ui.notify(`Loop started (${paceLabel(intervalMs)}): ${loop.prompt}`, 'info')
+        fire(ctx)
+    }
+
+    function stopLoop(ctx: ExtensionContext): void {
+        if (!loop) {
+            ctx.ui.notify('No loop running', 'info')
+            return
+        }
+        clearTimer()
+        const stopped = loop
+        loop = null
+        persist()
+        updateStatus(ctx)
+        ctx.ui.notify(
+            `Loop stopped (${stopped.iterations} run${stopped.iterations === 1 ? '' : 's'}): ${stopped.prompt}`,
+            'info'
+        )
+    }
+
+    function showStatus(ctx: ExtensionContext): void {
+        if (!loop) {
+            ctx.ui.notify('No loop running.\n\nUsage: /loop <interval> <prompt> | /loop <prompt> | /loop stop', 'info')
+            return
+        }
+        ctx.ui.notify(
+            `Loop (${paceLabel(loop.intervalMs)}): ${loop.prompt}\n${loop.iterations} run${loop.iterations === 1 ? '' : 's'}`,
+            'info'
+        )
+    }
+
+    function reconstructState(ctx: ExtensionContext): void {
+        clearTimer()
+        loop = null
+        for (const entry of ctx.sessionManager.getBranch()) {
+            if (entry.type !== 'custom' || entry.customType !== STATE_TYPE) continue
+            const data = entry.data
+            loop = isJsonObject(data) ? parseLoopState(data) : null
+        }
+        updateStatus(ctx)
+        if (!loop || loop.intervalMs === null) return
+
+        const elapsed = Date.now() - (loop.lastFiredAt ?? loop.createdAt)
+        const remaining = Math.max(0, loop.intervalMs - elapsed)
+        timer = setTimeout(() => fireSafely(ctx), remaining)
+    }
+
+    pi.on('session_start', async (_event, ctx) => reconstructState(ctx))
+    pi.on('session_tree', async (_event, ctx) => reconstructState(ctx))
+
+    pi.on('session_shutdown', async () => clearTimer())
+
+    pi.on('agent_end', async (event) => {
+        const assistant = event.messages.findLast((message) => message.role === 'assistant')
+        lastError =
+            assistant?.stopReason === 'error'
+                ? (assistant.errorMessage ?? 'the last turn ended with an error')
+                : undefined
+    })
+
+    pi.on('agent_settled', async (event, ctx) => {
+        if (!loop) return
+        if (lastError !== undefined) {
+            const reason = lastError
+            lastError = undefined
+            clearTimer()
+            loop = null
+            persist()
+            updateStatus(ctx)
+            ctx.ui.notify(`Loop stopped: ${reason}`, 'warning')
+            return
+        }
+        if (loop.intervalMs !== null) return
+        if (event.aborted) return
+        clearTimer()
+        timer = setTimeout(() => fireSafely(ctx), SELF_PACE_DELAY_MS)
+    })
+
+    pi.registerCommand('loop', {
+        description: 'Re-fire a prompt on an interval, or self-paced after each turn',
+        getArgumentCompletions: (prefix: string) => {
+            const items = [
+                { value: 'stop', label: 'stop', description: 'stop the current loop' },
+                { value: '5m', label: '5m', description: 'fire every 5 minutes' },
+                { value: '1h', label: '1h', description: 'fire every hour' }
+            ]
+            const filtered = items.filter((item) => item.value.startsWith(prefix.trimStart()))
+            return filtered.length > 0 ? filtered : null
+        },
+        handler: async (args, ctx) => {
+            const parsed = parseLoopArgs(args)
+            switch (parsed.kind) {
+                case 'status':
+                    showStatus(ctx)
+                    return
+                case 'stop':
+                    stopLoop(ctx)
+                    return
+                case 'start':
+                    startLoop(ctx, parsed.prompt, parsed.intervalMs)
+                    return
+            }
+        }
+    })
+}

package/src/loop/logic.ts

@@ -0,0 +1,60 @@
+export type LoopState = {
+    prompt: string
+    intervalMs: number | null
+    iterations: number
+    createdAt: number
+    lastFiredAt: number | null
+}
+
+export type ParsedLoopArgs =
+    | { kind: 'stop' }
+    | { kind: 'status' }
+    | { kind: 'start'; prompt: string; intervalMs: number | null }
+
+const INTERVAL_PATTERN = /^(\d+)(ms|s|m|h|d)$/i
+const MS_PER_UNIT = { ms: 1, s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 } satisfies Record<string, number>
+export const MAX_INTERVAL_MS = 2_147_483_647
+export const MIN_INTERVAL_MS = 10_000
+const STOP_WORDS = new Set(['stop', 'cancel', 'clear', 'off'])
+
+export function parseInterval(token: string): number | null {
+    const match = INTERVAL_PATTERN.exec(token)
+    if (!match) return null
+    const amount = parseInt(match[1] ?? '', 10)
+    const unit = (match[2] ?? '').toLowerCase()
+    const msPerUnit = MS_PER_UNIT[unit as keyof typeof MS_PER_UNIT]
+    if (!Number.isFinite(amount) || amount <= 0 || msPerUnit === undefined) return null
+    return Math.min(Math.max(amount * msPerUnit, MIN_INTERVAL_MS), MAX_INTERVAL_MS)
+}
+
+export function parseLoopArgs(input: string): ParsedLoopArgs {
+    const trimmed = input.trim()
+    if (!trimmed) return { kind: 'status' }
+    if (STOP_WORDS.has(trimmed.toLowerCase())) return { kind: 'stop' }
+
+    const spaceIndex = trimmed.indexOf(' ')
+    const firstToken = spaceIndex === -1 ? trimmed : trimmed.slice(0, spaceIndex)
+    const intervalMs = parseInterval(firstToken)
+    if (intervalMs === null) return { kind: 'start', prompt: trimmed, intervalMs: null }
+
+    const prompt = spaceIndex === -1 ? '' : trimmed.slice(spaceIndex + 1).trim()
+    return { kind: 'start', prompt, intervalMs }
+}
+
+export function paceLabel(intervalMs: number | null): string {
+    if (intervalMs === null) return 'self-paced'
+    return `every ${formatDuration(intervalMs)}`
+}
+
+export function formatDuration(ms: number): string {
+    if (ms < 1_000) return `${ms}ms`
+    const totalSeconds = Math.round(ms / 1_000)
+    const days = Math.floor(totalSeconds / 86_400)
+    const hours = Math.floor((totalSeconds % 86_400) / 3_600)
+    const minutes = Math.floor((totalSeconds % 3_600) / 60)
+    const seconds = totalSeconds % 60
+    if (days > 0) return `${days}d ${hours}h`
+    if (hours > 0) return `${hours}h ${minutes}m`
+    if (minutes > 0) return `${minutes}m`
+    return `${seconds}s`
+}