feat: allow editing loaded plans

Author: chriswritescode-dev

src/tui.tsx

@@ -14,6 +14,7 @@ import type { PluginConfig } from './types'
 import { ExecutePlanPanel } from './tui/execute-plan-panel'
 import { connectForgeProject, type ForgeProjectClient } from './utils/tui-client'
 import { savePlanToArchive, listArchivedPlans, readArchivedPlan, resolvePlanArchiveDir, hashPlanContent, DEFAULT_PLAN_ARCHIVE_TTL_MS, type ArchivedPlan } from './utils/plan-archive'
+import { savePlanFromDialog } from './utils/plan-save-target'
 
 type TuiKeybinds = {
   viewPlan: string
@@ -103,15 +104,61 @@ function PlanViewerDialog(props: {
 
   const handleSave = async () => {
     const text = textareaRef?.plainText ?? content()
-    const saved = await props.client.plan.write(props.sessionId, text)
-    props.api.ui.toast({
-      message: saved ? 'Plan saved' : 'Failed to save plan',
-      variant: saved ? 'success' : 'error',
-      duration: 3000,
+    const ttlMs = props.pluginConfig.tui?.planArchiveTtlMs ?? DEFAULT_PLAN_ARCHIVE_TTL_MS
+    const outcome = await savePlanFromDialog({
+      sessionId: props.sessionId || undefined,
+      projectId: props.client.projectId,
+      text,
+      ttlMs,
+      writeSession: (sid, value) => props.client.plan.write(sid, value),
     })
-    if (saved) {
+
+    if (outcome.kind === 'session') {
+      props.api.ui.toast({
+        message: outcome.ok ? 'Plan saved' : 'Failed to save plan',
+        variant: outcome.ok ? 'success' : 'error',
+        duration: 3000,
+      })
+      if (outcome.ok) {
+        setContent(text)
+        setEditing(false)
+      }
+      return
+    }
+
+    if (outcome.kind === 'archive' && outcome.ok) {
+      props.api.ui.toast({
+        message: outcome.deduped ? 'Plan unchanged (already archived)' : 'Plan archived',
+        variant: 'success',
+        duration: 3000,
+      })
       setContent(text)
       setEditing(false)
+      void props.onRefresh?.()
+      return
+    }
+
+    if (outcome.kind === 'archive' && !outcome.ok) {
+      props.api.ui.toast({
+        message: `Failed to archive plan: ${outcome.error.message}`,
+        variant: 'error',
+        duration: 4000,
+      })
+      return
+    }
+
+    props.api.ui.toast({
+      message: 'No session or project context to save into',
+      variant: 'warning',
+      duration: 4000,
+    })
+  }
+
+  const flushTextareaToContent = () => {
+    if (!editing()) return
+    const text = textareaRef?.plainText
+    if (typeof text === 'string' && text !== content()) {
+      setContent(text)
     }
   }
 
@@ -162,10 +209,10 @@ function PlanViewerDialog(props: {
           onSelect={(_, option) => {
             if (!option) return
             switch (option.value) {
-              case 'view': setEditing(false); setExecuting(false); break
+              case 'view': flushTextareaToContent(); setEditing(false); setExecuting(false); break
               case 'edit': setEditing(true); setExecuting(false); break
-              case 'execute': setEditing(false); setExecuting(true); break
-              case 'export': handleExport(); break
+              case 'execute': flushTextareaToContent(); setEditing(false); setExecuting(true); break
+              case 'export': flushTextareaToContent(); handleExport(); break
             }
           }}
           showUnderline={false}
@@ -293,7 +340,6 @@ function LoadPlanDialog(props: {
             pluginConfig={props.pluginConfig}
             planContent={content}
             sessionId={props.sessionId ?? ''}
-            startInExecuteMode={true}
             onRefresh={props.onRefresh}
           />
         ))

src/utils/plan-save-target.ts

@@ -0,0 +1,36 @@
+import { savePlanToArchive, DEFAULT_PLAN_ARCHIVE_TTL_MS } from './plan-archive'
+
+export type PlanSaveOutcome =
+  | { kind: 'session'; ok: boolean }
+  | { kind: 'archive'; ok: true; deduped: boolean; filepath: string; filename: string }
+  | { kind: 'archive'; ok: false; error: Error }
+  | { kind: 'noop'; reason: 'missing-project' }
+
+export interface SavePlanFromDialogArgs {
+  sessionId: string | undefined
+  projectId: string | undefined
+  text: string
+  ttlMs?: number
+  writeSession: (sessionId: string, text: string) => Promise<boolean>
+  now?: Date
+}
+
+export async function savePlanFromDialog(args: SavePlanFromDialogArgs): Promise<PlanSaveOutcome> {
+  const { sessionId, projectId, text, writeSession } = args
+  if (sessionId) {
+    const ok = await writeSession(sessionId, text)
+    return { kind: 'session', ok }
+  }
+  if (!projectId) return { kind: 'noop', reason: 'missing-project' }
+  try {
+    const { deduped, filepath, filename } = savePlanToArchive(
+      projectId,
+      text,
+      args.now ?? new Date(),
+      args.ttlMs ?? DEFAULT_PLAN_ARCHIVE_TTL_MS,
+    )
+    return { kind: 'archive', ok: true, deduped, filepath, filename }
+  } catch (err) {
+    return { kind: 'archive', ok: false, error: err as Error }
+  }
+}

test/utils/plan-save-target.test.ts

@@ -0,0 +1,119 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import { savePlanFromDialog } from '../../src/utils/plan-save-target'
+import { resolvePlanArchiveDir } from '../../src/utils/plan-archive'
+
+const TEST_DIR = '/tmp/opencode-forge-plan-save-target-test-' + Date.now()
+
+describe('savePlanFromDialog', () => {
+  let testDataDir: string
+
+  beforeEach(() => {
+    testDataDir = TEST_DIR + '-data-' + Math.random().toString(36).slice(2)
+    process.env['XDG_DATA_HOME'] = testDataDir
+  })
+
+  afterEach(() => {
+    delete process.env['XDG_DATA_HOME']
+    if (existsSync(testDataDir)) {
+      rmSync(testDataDir, { recursive: true, force: true })
+    }
+  })
+
+  test('sessionId present writes to session and does not touch archive', async () => {
+    const calls: Array<[string, string]> = []
+    const outcome = await savePlanFromDialog({
+      sessionId: 'session-1',
+      projectId: 'project-1',
+      text: '# Session Plan',
+      writeSession: async (sessionId, text) => {
+        calls.push([sessionId, text])
+        return true
+      },
+    })
+
+    expect(calls).toEqual([['session-1', '# Session Plan']])
+    expect(existsSync(resolvePlanArchiveDir('project-1'))).toBe(false)
+    expect(outcome).toEqual({ kind: 'session', ok: true })
+  })
+
+  test('sessionId present returns false when session write fails', async () => {
+    const outcome = await savePlanFromDialog({
+      sessionId: 'session-1',
+      projectId: 'project-1',
+      text: '# Session Plan',
+      writeSession: async () => false,
+    })
+
+    expect(outcome).toEqual({ kind: 'session', ok: false })
+  })
+
+  test('sessionId empty archives and dedupes identical content', async () => {
+    let sessionWrites = 0
+    const args = {
+      sessionId: undefined,
+      projectId: 'project-archive',
+      text: '# Archived Plan',
+      writeSession: async () => {
+        sessionWrites += 1
+        return true
+      },
+      now: new Date('2026-05-04T12:00:00.000Z'),
+    }
+
+    const first = await savePlanFromDialog(args)
+    const second = await savePlanFromDialog(args)
+
+    expect(sessionWrites).toBe(0)
+    if (first.kind === 'archive' && first.ok) {
+      expect(first.deduped).toBe(false)
+      expect(first.filename).toMatch(/^[0-9a-f]{64}\.md$/)
+      expect(existsSync(first.filepath)).toBe(true)
+    } else {
+      throw new Error('expected archive success')
+    }
+    if (second.kind === 'archive' && second.ok) {
+      expect(second.deduped).toBe(true)
+      expect(existsSync(second.filepath)).toBe(true)
+    } else {
+      throw new Error('expected archive success')
+    }
+  })
+
+  test('sessionId empty and projectId missing returns noop and writes nothing', async () => {
+    let sessionWrites = 0
+    const outcome = await savePlanFromDialog({
+      sessionId: '',
+      projectId: undefined,
+      text: '# No Context',
+      writeSession: async () => {
+        sessionWrites += 1
+        return true
+      },
+    })
+
+    expect(sessionWrites).toBe(0)
+    expect(outcome).toEqual({ kind: 'noop', reason: 'missing-project' })
+    expect(existsSync(join(testDataDir, 'opencode', 'forge', 'plans'))).toBe(false)
+  })
+
+  test('archive write errors are returned as archive failures', async () => {
+    const sentinel = join(testDataDir, 'opencode')
+    mkdirSync(testDataDir, { recursive: true })
+    writeFileSync(sentinel, 'not a directory')
+
+    const outcome = await savePlanFromDialog({
+      sessionId: undefined,
+      projectId: 'project-error',
+      text: '# Error Plan',
+      writeSession: async () => true,
+    })
+
+    if (outcome.kind === 'archive' && !outcome.ok) {
+      expect(outcome.error).toBeInstanceOf(Error)
+    } else {
+      throw new Error('expected archive failure')
+    }
+  })
+})