feat: add idea backup/history before processing

- Add ideasHistoryDir path (.opencode/opencoder/ideas/history/)
- Create archiveIdea() function to copy ideas before removal
- Archive idea to timestamped file (YYYYMMDD_HHMMSS_filename.md)
- Ensure ideas history directory is created on startup
- Add comprehensive tests for archiving functionality

Signed-off-by: leocavalcante <[email protected]>

Author: leocavalcante

src/fs.ts

@@ -17,6 +17,7 @@ const OPENCODER_SUBDIR = "opencoder"
  */
 export function initializePaths(projectDir: string): Paths {
 	const opencoderDir = join(resolve(projectDir), OPENCODE_DIR, OPENCODER_SUBDIR)
+	const ideasDir = join(opencoderDir, "ideas")
 
 	return {
 		opencoderDir,
@@ -26,7 +27,8 @@ export function initializePaths(projectDir: string): Paths {
 		cycleLogDir: join(opencoderDir, "logs", "cycles"),
 		alertsFile: join(opencoderDir, "alerts.log"),
 		historyDir: join(opencoderDir, "history"),
-		ideasDir: join(opencoderDir, "ideas"),
+		ideasDir,
+		ideasHistoryDir: join(ideasDir, "history"),
 		configFile: join(opencoderDir, "config.json"),
 	}
 }
@@ -43,6 +45,7 @@ export function ensureDirectories(paths: Paths): void {
 		paths.cycleLogDir,
 		paths.historyDir,
 		paths.ideasDir,
+		paths.ideasHistoryDir,
 	]
 
 	for (const dir of directories) {

src/ideas.ts

@@ -5,7 +5,7 @@
  * for the autonomous loop to work on.
  */
 
-import { existsSync, readdirSync, unlinkSync } from "node:fs"
+import { copyFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "node:fs"
 import { join } from "node:path"
 import type { Idea } from "./types.ts"
 
@@ -117,6 +117,41 @@ export function removeIdea(ideaPath: string): boolean {
 	}
 }
 
+/**
+ * Archive an idea file to the history directory before processing.
+ * Creates a timestamped copy for future reference.
+ * @param ideaPath - Path to the idea file to archive
+ * @param historyDir - Directory to store archived ideas
+ * @returns The path to the archived file, or null if archiving failed
+ */
+export function archiveIdea(ideaPath: string, historyDir: string): string | null {
+	try {
+		if (!existsSync(ideaPath)) {
+			return null
+		}
+
+		// Ensure history directory exists
+		if (!existsSync(historyDir)) {
+			mkdirSync(historyDir, { recursive: true })
+		}
+
+		// Generate timestamped filename: YYYYMMDD_HHMMSS_originalname.md
+		const timestamp = new Date().toISOString().replace(/[-:]/g, "").replace("T", "_").slice(0, 15)
+		const originalFilename = ideaPath.split("/").pop() || "idea.md"
+		const archiveFilename = `${timestamp}_${originalFilename}`
+		const archivePath = join(historyDir, archiveFilename)
+
+		copyFileSync(ideaPath, archivePath)
+		return archivePath
+	} catch (err) {
+		// Failed to archive idea file
+		if (process.env.DEBUG) {
+			console.debug(`[ideas] Failed to archive ${ideaPath}: ${err}`)
+		}
+		return null
+	}
+}
+
 /**
  * Remove an idea by index from a list
  */

src/loop.ts

@@ -19,7 +19,13 @@ import {
 	writeFile,
 } from "./fs.ts"
 import { commitChanges, generateCommitMessage, hasChanges, pushChanges } from "./git.ts"
-import { formatIdeasForSelection, loadAllIdeas, parseIdeaSelection, removeIdea } from "./ideas.ts"
+import {
+	archiveIdea,
+	formatIdeasForSelection,
+	loadAllIdeas,
+	parseIdeaSelection,
+	removeIdea,
+} from "./ideas.ts"
 import { Logger } from "./logger.ts"
 import { getTasks, getUncompletedTasks, markTaskComplete, validatePlan } from "./plan.ts"
 import { loadState, saveState } from "./state.ts"
@@ -310,8 +316,14 @@ async function runPlanPhase(
 	const tasks = getTasks(planContent)
 	logger.success(`Plan created with ${tasks.length} tasks`)
 
-	// Only NOW remove the idea file, after plan is safely saved
+	// Archive and remove the idea file, after plan is safely saved
 	if (ideaToRemove) {
+		// Archive to history before removing
+		const archivePath = archiveIdea(ideaToRemove.path, paths.ideasHistoryDir)
+		if (archivePath) {
+			logger.logVerbose(`Archived idea to: ${archivePath}`)
+		}
+
 		const removed = removeIdea(ideaToRemove.path)
 		if (removed) {
 			logger.logVerbose(`Removed processed idea: ${ideaToRemove.filename}`)

src/types.ts

@@ -103,6 +103,8 @@ export interface Paths {
 	historyDir: string
 	/** .opencoder/ideas/ */
 	ideasDir: string
+	/** .opencoder/ideas/history/ */
+	ideasHistoryDir: string
 	/** opencoder.json config file */
 	configFile: string
 }

tests/fs.test.ts

@@ -49,6 +49,7 @@ describe("fs", () => {
 			expect(paths.alertsFile).toBe("/project/.opencode/opencoder/alerts.log")
 			expect(paths.historyDir).toBe("/project/.opencode/opencoder/history")
 			expect(paths.ideasDir).toBe("/project/.opencode/opencoder/ideas")
+			expect(paths.ideasHistoryDir).toBe("/project/.opencode/opencoder/ideas/history")
 			expect(paths.configFile).toBe("/project/.opencode/opencoder/config.json")
 		})
 
@@ -70,6 +71,7 @@ describe("fs", () => {
 			expect(existsSync(paths.cycleLogDir)).toBe(true)
 			expect(existsSync(paths.historyDir)).toBe(true)
 			expect(existsSync(paths.ideasDir)).toBe(true)
+			expect(existsSync(paths.ideasHistoryDir)).toBe(true)
 		})
 
 		test("handles existing directories", () => {

tests/ideas.test.ts

@@ -6,6 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { existsSync, mkdirSync, rmSync } from "node:fs"
 import { join } from "node:path"
 import {
+	archiveIdea,
 	countIdeas,
 	formatIdeasForSelection,
 	getIdeaSummary,
@@ -163,4 +164,59 @@ describe("ideas", () => {
 			expect(result).toBe(false)
 		})
 	})
+
+	describe("archiveIdea", () => {
+		test("archives idea to history directory", async () => {
+			const ideaPath = join(TEST_DIR, "my-idea.md")
+			const historyDir = join(TEST_DIR, "history")
+			await Bun.write(ideaPath, "# Test Idea\nContent here")
+
+			const archivePath = archiveIdea(ideaPath, historyDir)
+
+			expect(archivePath).not.toBeNull()
+			if (!archivePath) return // Type guard
+			expect(existsSync(archivePath)).toBe(true)
+			expect(archivePath).toContain("_my-idea.md")
+			// Original file should still exist
+			expect(existsSync(ideaPath)).toBe(true)
+
+			// Verify content was copied
+			const archivedContent = await Bun.file(archivePath).text()
+			expect(archivedContent).toBe("# Test Idea\nContent here")
+		})
+
+		test("creates history directory if it doesn't exist", async () => {
+			const ideaPath = join(TEST_DIR, "idea.md")
+			const historyDir = join(TEST_DIR, "new-history-dir")
+			await Bun.write(ideaPath, "content")
+
+			expect(existsSync(historyDir)).toBe(false)
+
+			const archivePath = archiveIdea(ideaPath, historyDir)
+
+			expect(archivePath).not.toBeNull()
+			expect(existsSync(historyDir)).toBe(true)
+		})
+
+		test("returns null for non-existent idea", () => {
+			const historyDir = join(TEST_DIR, "history")
+			const archivePath = archiveIdea("/nonexistent/idea.md", historyDir)
+
+			expect(archivePath).toBeNull()
+		})
+
+		test("generates timestamped filename", async () => {
+			const ideaPath = join(TEST_DIR, "feature.md")
+			const historyDir = join(TEST_DIR, "history")
+			await Bun.write(ideaPath, "content")
+
+			const archivePath = archiveIdea(ideaPath, historyDir)
+
+			expect(archivePath).not.toBeNull()
+			if (!archivePath) return // Type guard
+			// Should match pattern: YYYYMMDD_HHMMSS_filename.md
+			const filename = archivePath.split("/").pop()
+			expect(filename).toMatch(/^\d{8}_\d{6}_feature\.md$/)
+		})
+	})
 })