poe-code 4.0.49 → 4.0.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "4.0.49",
+  "version": "4.0.51",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/plan-browser/dist/actions.d.ts

@@ -21,6 +21,9 @@ export declare function editPlan(absolutePath: string, options: {
 declare function archiveSelectedPlan(entry: Pick<{
     absolutePath: string;
 }, "absolutePath">, fs: ActionFs): Promise<string>;
+export declare function unarchivePlan(entry: Pick<{
+    absolutePath: string;
+}, "absolutePath">, fs: ActionFs): Promise<string>;
 export declare function savePlanForLater(entry: Pick<{
     absolutePath: string;
     format: PlanFormat;

package/packages/plan-browser/dist/actions.js

@@ -102,6 +102,26 @@ async function archiveSelectedPlan(entry, fs) {
     }
     return archivedPath;
 }
+export async function unarchivePlan(entry, fs) {
+    rejectPlanMetaDocument(entry.absolutePath, "unarchive");
+    const archiveDir = path.dirname(entry.absolutePath);
+    if (path.basename(archiveDir) !== "archive") {
+        throw new Error(`Plan is not archived: ${entry.absolutePath}`);
+    }
+    await rejectSymbolicLink(archiveDir, fs, "unarchive plan through");
+    const destinationPath = path.join(path.dirname(archiveDir), path.basename(entry.absolutePath));
+    try {
+        await fs.readFile(destinationPath, "utf8");
+        throw new Error(`Unarchive destination already exists: ${destinationPath}`);
+    }
+    catch (error) {
+        if (!hasErrorCode(error, "ENOENT")) {
+            throw error;
+        }
+    }
+    await fs.rename(entry.absolutePath, destinationPath);
+    return destinationPath;
+}
 export async function savePlanForLater(entry, fs, options = {}) {
     const reason = entry.savedForLater?.reason?.trim() || options.reason?.trim();
     if (!reason) {

package/packages/plan-browser/dist/browser.d.ts

@@ -8,6 +8,7 @@ export declare function runPlanBrowser(options: {
     projectConfigPath: string;
     fs: DiscoveryFs & Partial<ActionFs>;
     kind?: PlanKind;
+    archived?: boolean;
     variables?: Record<string, string | undefined>;
     runExplorerImpl?: RunExplorerImpl;
 }): Promise<void>;

package/packages/plan-browser/dist/browser.js

@@ -9,6 +9,7 @@ export async function runPlanBrowser(options) {
         projectConfigPath: options.projectConfigPath,
         fs: options.fs,
         kind: options.kind,
+        archived: options.archived,
         variables: options.variables
     });
     const plans = await discover();
@@ -26,6 +27,7 @@ export async function runPlanBrowser(options) {
     }
     const config = buildPlanExplorerConfig({
         plans,
+        archived: options.archived,
         fs: options.fs,
         variables: options.variables ?? process.env,
         homeDir: options.homeDir,

package/packages/plan-browser/dist/discovery.d.ts

@@ -7,5 +7,6 @@ export declare function discoverAllPlans(options: {
     configPath: string;
     projectConfigPath: string;
     kind?: PlanKind;
+    archived?: boolean;
     variables?: Record<string, string | undefined>;
 }): Promise<PlanEntry[]>;

package/packages/plan-browser/dist/discovery.js

@@ -108,7 +108,7 @@ function toPlanKind(value, filePath) {
     }
     throw new Error(`${filePath}: unsupported frontmatter kind ${JSON.stringify(value)}`);
 }
-function classifyPlanKind(content, filePath) {
+function classifyPlanKind(content, filePath, archived = false) {
     if (isYamlPlanFile(filePath)) {
         parsePlan(content);
         return "pipeline";
@@ -117,7 +117,19 @@ function classifyPlanKind(content, filePath) {
     if (data === undefined) {
         return "plan";
     }
-    return data.kind === undefined ? "plan" : toPlanKind(data.kind, filePath);
+    if (data.kind === undefined)
+        return "plan";
+    if (archived && data.kind === "archived-pipeline-plan")
+        return "plan";
+    if (archived) {
+        try {
+            return toPlanKind(data.kind, filePath);
+        }
+        catch {
+            return "plan";
+        }
+    }
+    return toPlanKind(data.kind, filePath);
 }
 function readPlanReadiness(content, filePath) {
     const value = splitFrontmatter(content, filePath).data?.readiness;
@@ -142,6 +154,14 @@ async function discoverSharedPlans(options) {
     if (canonicalDir !== path.resolve(absoluteDir)) {
         throw new Error(`Plan directory must not be a symbolic link: ${displayDir}`);
     }
+    if (options.archived === true) {
+        return discoverPlanDirectoryEntries({
+            ...options,
+            absoluteDir: path.join(absoluteDir, "archive"),
+            displayDir: path.join(displayDir, "archive"),
+            savedForLaterDirectory: false
+        });
+    }
     const activePlans = await discoverPlanDirectoryEntries({
         ...options,
         absoluteDir,
@@ -199,20 +219,35 @@ async function discoverPlanDirectoryEntries(options) {
         }
         const displayPath = path.join(options.displayDir, name);
         const content = await options.fs.readFile(absolutePath, "utf8");
-        const kind = classifyPlanKind(content, displayPath);
+        let kind = classifyPlanKind(content, displayPath, options.archived);
+        const savedForLater = options.savedForLaterDirectory
+            ? (readSavedForLaterMetadata(content, displayPath) ?? {})
+            : readSavedForLaterMetadata(content, displayPath);
+        let metadata;
+        try {
+            metadata = await readPlanMetadata({
+                kind,
+                absolutePath,
+                path: displayPath,
+                fs: options.fs,
+                content
+            });
+        }
+        catch (error) {
+            if (!options.archived || kind === "plan")
+                throw error;
+            kind = "plan";
+            metadata = await readPlanMetadata({
+                kind,
+                absolutePath,
+                path: displayPath,
+                fs: options.fs,
+                content
+            });
+        }
         if (options.kind && kind !== options.kind) {
             continue;
         }
-        const savedForLater = options.savedForLaterDirectory
-            ? readSavedForLaterMetadata(content, displayPath) ?? {}
-            : readSavedForLaterMetadata(content, displayPath);
-        const metadata = await readPlanMetadata({
-            kind,
-            absolutePath,
-            path: displayPath,
-            fs: options.fs,
-            content
-        });
         plans.push({
             path: displayPath,
             absolutePath,

package/packages/plan-browser/dist/explorer-config.d.ts

@@ -2,6 +2,7 @@ import type { ExplorerConfig } from "../../toolcraft-design/dist/index.js";
 import type { ActionFs, DiscoveryFs, PlanEntry } from "./types.js";
 export interface BuildPlanExplorerConfigOptions {
     plans: PlanEntry[];
+    archived?: boolean;
     fs: ActionFs & DiscoveryFs;
     variables: Record<string, string | undefined>;
     homeDir?: string;

package/packages/plan-browser/dist/explorer-config.js

@@ -1,20 +1,20 @@
 import path from "node:path";
 import { formatPlanReadinessLabel } from "@poe-code/agent-harness-tools";
 import { normalizeExplorerConfig } from "toolcraft-design";
-import { archivePlan, deletePlan, editFile, restorePlanFromLater, savePlanForLater, setPlanReadiness } from "./actions.js";
+import { archivePlan, deletePlan, editFile, restorePlanFromLater, savePlanForLater, setPlanReadiness, unarchivePlan } from "./actions.js";
 import { loadPlanPreviewMarkdown } from "./format.js";
 export function buildPlanExplorerConfig(options) {
     const loadDetailMarkdown = options.loadDetailMarkdown ?? loadPlanPreviewMarkdown;
     const promptSaveReason = options.promptSaveReason;
     let plans = options.plans;
-    let rows = toRows(plans);
+    let rows = toRows(plans, options.archived);
     let entryByRowId = toEntryMap(plans);
     let preserveOrderOnNextRefresh = false;
     async function refresh() {
         const refreshedPlans = await options.onRefresh();
         plans = preserveOrderOnNextRefresh ? preservePlanOrder(plans, refreshedPlans) : refreshedPlans;
         preserveOrderOnNextRefresh = false;
-        rows = toRows(plans);
+        rows = toRows(plans, options.archived);
         entryByRowId = toEntryMap(plans);
     }
     const actions = [
@@ -108,6 +108,22 @@ export function buildPlanExplorerConfig(options) {
                 }
             }
         },
+        {
+            id: "unarchive",
+            accelerator: "a",
+            label: "Unarchive",
+            handler: async (ctx) => {
+                const entry = getEntry(entryByRowId, ctx.row.id);
+                await unarchivePlan(entry, options.fs);
+                try {
+                    await ctx.refresh();
+                    ctx.toast(`Unarchived ${path.basename(entry.path)}`, "info");
+                }
+                catch {
+                    ctx.toast(`Unarchived ${path.basename(entry.path)}; refresh failed`, "info");
+                }
+            }
+        },
         {
             id: "delete",
             accelerator: "x",
@@ -154,41 +170,49 @@ export function buildPlanExplorerConfig(options) {
             }
         ],
         refresh,
-        actions,
-        reorder: {
-            onReorder: async (orderedIds, ctx) => {
-                if (ctx === undefined) {
-                    throw new Error("Plan reorder context is required");
-                }
-                const orderedEntries = orderedIds.map((id) => getEntry(entryByRowId, id));
-                const movedIndex = orderedIds.indexOf(ctx.movedId);
-                const originalIndex = createRowIds(plans).indexOf(ctx.movedId);
-                if (movedIndex < 0 || originalIndex < 0) {
-                    throw new Error(`Plan row is no longer available: ${ctx.movedId}`);
-                }
-                const moved = orderedEntries[movedIndex];
-                const swapTarget = orderedEntries[originalIndex];
-                if (swapTarget === undefined || swapTarget.readiness !== moved.readiness) {
-                    throw new Error("Plans can only be reordered within the same readiness group");
-                }
-                if (isSavedForLaterEntry(swapTarget) !== isSavedForLaterEntry(moved)) {
-                    throw new Error("Active and saved-for-later plans cannot be reordered together");
+        actions: options.archived
+            ? actions.filter((action) => action.id === "edit" || action.id === "unarchive" || action.id === "delete")
+            : actions.filter((action) => action.id !== "unarchive"),
+        ...(options.archived
+            ? {}
+            : {
+                reorder: {
+                    onReorder: async (orderedIds, ctx) => {
+                        if (ctx === undefined) {
+                            throw new Error("Plan reorder context is required");
+                        }
+                        const orderedEntries = orderedIds.map((id) => getEntry(entryByRowId, id));
+                        const movedIndex = orderedIds.indexOf(ctx.movedId);
+                        const originalIndex = createRowIds(plans).indexOf(ctx.movedId);
+                        if (movedIndex < 0 || originalIndex < 0) {
+                            throw new Error(`Plan row is no longer available: ${ctx.movedId}`);
+                        }
+                        const moved = orderedEntries[movedIndex];
+                        const swapTarget = orderedEntries[originalIndex];
+                        if (swapTarget === undefined || swapTarget.readiness !== moved.readiness) {
+                            throw new Error("Plans can only be reordered within the same readiness group");
+                        }
+                        if (isSavedForLaterEntry(swapTarget) !== isSavedForLaterEntry(moved)) {
+                            throw new Error("Active and saved-for-later plans cannot be reordered together");
+                        }
+                        const previousCandidate = orderedEntries[movedIndex - 1];
+                        const nextCandidate = orderedEntries[movedIndex + 1];
+                        const previous = sameOrderingGroup(previousCandidate, moved)
+                            ? previousCandidate
+                            : undefined;
+                        const next = sameOrderingGroup(nextCandidate, moved) ? nextCandidate : undefined;
+                        const [movedStat, previousStat, nextStat] = await Promise.all([
+                            options.fs.stat(moved.absolutePath),
+                            previous === undefined ? undefined : options.fs.stat(previous.absolutePath),
+                            next === undefined ? undefined : options.fs.stat(next.absolutePath)
+                        ]);
+                        const updatedAt = resolveMovedTimestamp(previousStat?.mtimeMs, nextStat?.mtimeMs);
+                        await options.fs.utimes(moved.absolutePath, new Date(movedStat.atimeMs ?? movedStat.mtimeMs), new Date(updatedAt));
+                        await ctx.refresh();
+                        ctx.toast(`Reordered ${path.basename(moved.path)}`, "info");
+                    }
                 }
-                const previousCandidate = orderedEntries[movedIndex - 1];
-                const nextCandidate = orderedEntries[movedIndex + 1];
-                const previous = sameOrderingGroup(previousCandidate, moved) ? previousCandidate : undefined;
-                const next = sameOrderingGroup(nextCandidate, moved) ? nextCandidate : undefined;
-                const [movedStat, previousStat, nextStat] = await Promise.all([
-                    options.fs.stat(moved.absolutePath),
-                    previous === undefined ? undefined : options.fs.stat(previous.absolutePath),
-                    next === undefined ? undefined : options.fs.stat(next.absolutePath)
-                ]);
-                const updatedAt = resolveMovedTimestamp(previousStat?.mtimeMs, nextStat?.mtimeMs);
-                await options.fs.utimes(moved.absolutePath, new Date(movedStat.atimeMs ?? movedStat.mtimeMs), new Date(updatedAt));
-                await ctx.refresh();
-                ctx.toast(`Reordered ${path.basename(moved.path)}`, "info");
-            }
-        },
+            }),
         multiSelect: false,
         emptyHint: "No plans found"
     });
@@ -239,14 +263,14 @@ function abbreviateHome(filePath, homeDir) {
     }
     return `~${path.sep}${relative}`;
 }
-function toRows(plans) {
+function toRows(plans, archived = false) {
     const rowIds = createRowIds(plans);
     return plans.map((entry, index) => ({
         id: rowIds[index],
         title: formatPlanReadinessLabel(path.basename(entry.path), entry.readiness),
         subtitle: formatSubtitle(entry),
         badge: { text: entry.typeLabel },
-        group: isSavedForLaterEntry(entry) ? "Saved for later" : "Active"
+        group: archived ? "Archived" : isSavedForLaterEntry(entry) ? "Saved for later" : "Active"
     }));
 }
 function formatSubtitle(entry) {

package/packages/plan-browser/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { discoverAllPlans } from "./discovery.js";
-export { archivePlan, deletePlan, editFile, editPlan, resolveEditor, restorePlanFromLater, savePlanForLater, setPlanReadiness } from "./actions.js";
+export { archivePlan, deletePlan, editFile, editPlan, resolveEditor, restorePlanFromLater, savePlanForLater, setPlanReadiness, unarchivePlan } from "./actions.js";
 export { buildPlanExplorerConfig } from "./explorer-config.js";
 export { deriveMarkdownTitle, formatExperimentDetail, formatPipelinePlanMarkdown, formatPipelineProgress, formatRalphDetail, formatSuperintendentDetail, getLastExperimentState, loadPlanPreviewMarkdown, readExperimentState, readPlanMetadata, readSavedForLaterMetadata, writeSavedForLaterReason } from "./format.js";
 export { runPlanBrowser } from "./browser.js";

package/packages/plan-browser/dist/index.js

@@ -1,5 +1,5 @@
 export { discoverAllPlans } from "./discovery.js";
-export { archivePlan, deletePlan, editFile, editPlan, resolveEditor, restorePlanFromLater, savePlanForLater, setPlanReadiness } from "./actions.js";
+export { archivePlan, deletePlan, editFile, editPlan, resolveEditor, restorePlanFromLater, savePlanForLater, setPlanReadiness, unarchivePlan } from "./actions.js";
 export { buildPlanExplorerConfig } from "./explorer-config.js";
 export { deriveMarkdownTitle, formatExperimentDetail, formatPipelinePlanMarkdown, formatPipelineProgress, formatRalphDetail, formatSuperintendentDetail, getLastExperimentState, loadPlanPreviewMarkdown, readExperimentState, readPlanMetadata, readSavedForLaterMetadata, writeSavedForLaterReason } from "./format.js";
 export { runPlanBrowser } from "./browser.js";