pi-quests 0.2.0 → 0.4.0

package/src/quest/dataplane.ts

@@ -1,30 +1,53 @@
 import type { AgentToolResult, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { DEFAULT_CONFIG, type ResolvedConfig } from "../config.js";
 import { logger } from "../logger.js";
 import {
+  formatAddResult,
   formatBatchAddResult,
-  formatClearResult,
+  formatBlockedBySubQuests,
   formatDeleteResult,
   formatNotFound,
   formatQuestList,
+  formatSubQuestCannotHaveSubQuests,
   formatToggleResult,
   formatUpdateResult,
 } from "./formatters.js";
-import { QUEST_ACTIONS, type Quest } from "./types.js";
+import { QUEST_ACTIONS, type Quest, type SubQuest } from "./types.js";
 
 export type HistoryEntry =
-  | { type: typeof QUEST_ACTIONS.add; id: number }
-  | { type: typeof QUEST_ACTIONS.toggle; id: number }
-  | { type: typeof QUEST_ACTIONS.update; id: number; previousDescription: string }
-  | { type: typeof QUEST_ACTIONS.delete; quest: Quest; index: number }
-  | { type: typeof QUEST_ACTIONS.clear; quests: Quest[]; nextId: number };
+  | { type: typeof QUEST_ACTIONS.add; id: string; parentId?: string }
+  | { type: typeof QUEST_ACTIONS.toggle; id: string }
+  | { type: typeof QUEST_ACTIONS.update; id: string; previousDescription: string }
+  | {
+      type: typeof QUEST_ACTIONS.delete;
+      quest: Quest | SubQuest;
+      index: number;
+      isSubQuest?: boolean;
+      cascadeDeletedSubs?: SubQuest[];
+    }
+  | {
+      type: typeof QUEST_ACTIONS.clear;
+      previousQuests: Quest[];
+      previousSubQuests?: SubQuest[];
+      all: false;
+    }
+  | { type: typeof QUEST_ACTIONS.clear; quests: Quest[]; subQuests?: SubQuest[]; all: true }
+  | {
+      type: typeof QUEST_ACTIONS.reorder;
+      quest: Quest;
+      oldIndex: number;
+      previousIds: string[];
+      targetId: string;
+    };
 
 export type QuestAction =
-  | { type: typeof QUEST_ACTIONS.add; descriptions?: string[] }
+  | { type: typeof QUEST_ACTIONS.add; descriptions?: string[]; parentId?: string }
   | { type: typeof QUEST_ACTIONS.list }
-  | { type: typeof QUEST_ACTIONS.toggle; id?: number }
-  | { type: typeof QUEST_ACTIONS.update; id?: number; description?: string }
-  | { type: typeof QUEST_ACTIONS.delete; id?: number }
-  | { type: typeof QUEST_ACTIONS.clear }
+  | { type: typeof QUEST_ACTIONS.toggle; id?: string }
+  | { type: typeof QUEST_ACTIONS.update; id?: string; description?: string }
+  | { type: typeof QUEST_ACTIONS.delete; id?: string }
+  | { type: typeof QUEST_ACTIONS.clear; all?: boolean }
+  | { type: typeof QUEST_ACTIONS.reorder; id?: string; targetId?: string }
   | { type: typeof QUEST_ACTIONS.revert };
 
 export type QuestOperationResult = { success: boolean; message: string; quest?: Quest };
@@ -37,8 +60,35 @@ export type QuestOperationResult = { success: boolean; message: string; quest?:
  */
 export class QuestLog {
   private quests: Quest[] = [];
-  private nextId = 1;
+  private subQuests: SubQuest[] = [];
+  private usedIds: Set<string> = new Set();
   private history: HistoryEntry[] = [];
+
+  private readonly ID_LENGTH: number;
+  private readonly MAX_IDS: number;
+
+  constructor(config: ResolvedConfig = DEFAULT_CONFIG) {
+    this.ID_LENGTH = config.ids.length;
+    this.MAX_IDS = 16 ** this.ID_LENGTH;
+  }
+
+  private generateId(): string {
+    if (this.usedIds.size >= this.MAX_IDS) {
+      logger.debug("quests:state", "generate-id-exhausted", { usedIds: this.usedIds.size });
+      throw new Error("No available quest IDs. Clear done or all quests to free up IDs.");
+    }
+
+    let id: string;
+    do {
+      id = Math.floor(Math.random() * this.MAX_IDS)
+        .toString(16)
+        .padStart(this.ID_LENGTH, "0")
+        .toLowerCase();
+    } while (this.usedIds.has(id));
+
+    this.usedIds.add(id);
+    return id;
+  }
   private undoHandlers: {
     [K in HistoryEntry["type"]]: (entry: Extract<HistoryEntry, { type: K }>) => {
       success: boolean;
@@ -47,68 +97,138 @@ export class QuestLog {
   } = {
     [QUEST_ACTIONS.add]: (entry) => {
       this.quests = this.quests.filter((q) => q.id !== entry.id);
+      this.subQuests = this.subQuests.filter((q) => q.id !== entry.id);
+      this.usedIds.delete(entry.id);
 
-      const maxId = this.quests.reduce((max, q) => Math.max(max, q.id), 0);
-      this.nextId = Math.max(maxId + 1, entry.id);
-
-      logger.debug("quests:state", "revert-add", { id: entry.id, total: this.quests.length });
-      return { success: true, message: `Reverted add quest #${entry.id}` };
+      logger.debug("quests:state", "revert-add", {
+        id: entry.id,
+        total: this.quests.length + this.subQuests.length,
+      });
+      return { success: true, message: `Reverted add quest [${entry.id}]` };
     },
     [QUEST_ACTIONS.toggle]: (entry) => {
-      const quest = this.quests.find((q) => q.id === entry.id);
+      const quest = this.findById(entry.id);
 
       if (quest) {
         quest.done = !quest.done;
         logger.debug("quests:state", "revert-toggle", { id: entry.id, done: quest.done });
-        return { success: true, message: `Reverted toggle for quest #${entry.id}` };
+        return { success: true, message: `Reverted toggle for quest [${entry.id}]` };
       }
 
       logger.debug("quests:state", "revert-toggle-not-found", { id: entry.id });
-      return { success: false, message: `Quest #${entry.id} not found` };
+      return { success: false, message: `Quest [${entry.id}] not found` };
     },
     [QUEST_ACTIONS.update]: (entry) => {
-      const quest = this.quests.find((q) => q.id === entry.id);
+      const quest = this.findById(entry.id);
       if (quest) {
         quest.description = entry.previousDescription;
         logger.debug("quests:state", "revert-update", { id: entry.id });
-        return { success: true, message: `Reverted update for quest #${entry.id}` };
+        return { success: true, message: `Reverted update for quest [${entry.id}]` };
       }
 
       logger.debug("quests:state", "revert-update-not-found", { id: entry.id });
-      return { success: false, message: `Quest #${entry.id} not found` };
+      return { success: false, message: `Quest [${entry.id}] not found` };
     },
     [QUEST_ACTIONS.delete]: (entry) => {
-      this.quests.splice(entry.index, 0, entry.quest);
+      if (entry.isSubQuest) {
+        this.subQuests.splice(entry.index, 0, entry.quest as unknown as SubQuest);
+      } else {
+        this.quests.splice(entry.index, 0, entry.quest);
+        if (entry.cascadeDeletedSubs) {
+          for (const sub of entry.cascadeDeletedSubs) {
+            this.subQuests.push(sub);
+            this.usedIds.add(sub.id);
+          }
+        }
+      }
+      this.usedIds.add(entry.quest.id);
 
       logger.debug("quests:state", "revert-delete", {
         id: entry.quest.id,
         index: entry.index,
-        total: this.quests.length,
+        total: this.quests.length + this.subQuests.length,
       });
-      return { success: true, message: `Reverted delete for quest #${entry.quest.id}` };
+      return { success: true, message: `Reverted delete for quest [${entry.quest.id}]` };
     },
     [QUEST_ACTIONS.clear]: (entry) => {
+      if ("previousQuests" in entry) {
+        const restoredCount =
+          entry.previousQuests.length +
+          (entry.previousSubQuests?.length ?? 0) -
+          (this.quests.length + this.subQuests.length);
+        this.quests = [...entry.previousQuests];
+        this.subQuests = [...(entry.previousSubQuests ?? [])];
+        this.usedIds = new Set([...this.quests, ...this.subQuests].map((q) => q.id));
+
+        return {
+          success: true,
+          message: `Reverted clear (${restoredCount} quests restored)`,
+        };
+      }
+
       this.quests = [...entry.quests];
-      this.nextId = entry.nextId;
+      this.subQuests = [...(entry.subQuests ?? [])];
+      this.usedIds = new Set([...this.quests, ...this.subQuests].map((q) => q.id));
 
-      logger.debug("quests:state", "revert-clear", { count: entry.quests.length });
       return { success: true, message: `Reverted clear (${entry.quests.length} quests restored)` };
     },
+    [QUEST_ACTIONS.reorder]: (entry) => {
+      const currentIndex = this.quests.indexOf(entry.quest);
+      if (currentIndex === -1) return { success: false, message: "Reordered quest not found" };
+
+      this.quests.splice(currentIndex, 1);
+      this.quests.splice(entry.oldIndex, 0, entry.quest);
+      for (let i = 0; i < this.quests.length; i++) {
+        this.quests[i].id = entry.previousIds[i];
+      }
+
+      return { success: true, message: `Reverted reorder for quest [${entry.quest.id}]` };
+    },
   };
 
+  /*
+   * Returns all quests including sub-quests, inserted in order
+   * sub-quests are returned immediately after their parent quest
+   */
   getAll(): Quest[] {
+    const result: Quest[] = [];
+    for (const q of this.quests) {
+      result.push(q);
+      result.push(...this.subQuests.filter((sq) => sq.parentId === q.id));
+    }
+    return result;
+  }
+
+  /*
+   * Returns only top-level quests. Sub-quests should be accessed via `getSubQuests()`.
+   */
+  getQuests(): Quest[] {
     return [...this.quests];
   }
 
-  getNextId(): number {
-    return this.nextId;
+  /*
+   * Returns sub-quests for a given parent quest ID. Sub-quests are not included in `getQuests()`.
+   */
+  getSubQuests(parentId: string): SubQuest[] {
+    return this.subQuests.filter((sq) => sq.parentId === parentId);
+  }
+
+  getParentQuest(subQuest: SubQuest): Quest | undefined {
+    return this.quests.find((q) => q.id === subQuest.parentId);
   }
 
-  add(description: string, additionalContext?: string): Quest {
+  private findById(id: string): Quest | SubQuest | undefined {
+    return this.quests.find((q) => q.id === id) ?? this.subQuests.find((sq) => sq.id === id);
+  }
+
+  getUsedIds(): string[] {
+    return Array.from(this.usedIds);
+  }
+
+  add(description: string): Quest {
     const quest: Quest = {
-      id: this.nextId++,
+      id: this.generateId(),
       description,
-      additionalContext,
       done: false,
       createdAt: Date.now(),
     };
@@ -124,26 +244,63 @@ export class QuestLog {
     return quest;
   }
 
-  toggle(id: number): Quest | undefined {
-    const quest = this.quests.find((q) => q.id === id);
+  addSubQuest(description: string, parentId: string): SubQuest {
+    if (this.subQuests.some((sq) => sq.id === parentId)) {
+      throw new Error(formatSubQuestCannotHaveSubQuests(parentId));
+    }
+    const parent = this.quests.find((q) => q.id === parentId);
+    if (!parent) {
+      throw new Error(`Parent quest [${parentId}] not found`);
+    }
+    if (parent.done) {
+      throw new Error(`Cannot add sub-quest to completed parent quest [${parentId}]`);
+    }
+    const subQuest: SubQuest = {
+      id: this.generateId(),
+      description,
+      done: false,
+      createdAt: Date.now(),
+      parentId,
+    };
+    this.subQuests.push(subQuest);
+    this.history.push({ type: QUEST_ACTIONS.add, id: subQuest.id, parentId });
+    logger.debug("quests:state", "add-subquest", {
+      id: subQuest.id,
+      parentId,
+      description,
+      totalSubQuests: this.subQuests.length,
+    });
+    return subQuest;
+  }
+
+  toggle(id: string): Quest | SubQuest | null | undefined {
+    const quest = this.findById(id);
     if (!quest) {
       logger.debug("quests:state", "toggle-not-found", { id });
       return undefined;
     }
 
+    if (!quest.done && !("parentId" in quest)) {
+      const subs = this.getSubQuests(id);
+      if (subs.some((q) => !q.done)) {
+        logger.debug("quests:state", "toggle-blocked-subquests", { id });
+        return null;
+      }
+    }
+
     quest.done = !quest.done;
     this.history.push({ type: QUEST_ACTIONS.toggle, id });
 
     logger.debug("quests:state", QUEST_ACTIONS.toggle, {
       id,
       done: quest.done,
-      total: this.quests.length,
+      total: this.quests.length + this.subQuests.length,
     });
     return quest;
   }
 
-  update(id: number, description: string): Quest | undefined {
-    const quest = this.quests.find((q) => q.id === id);
+  update(id: string, description: string): Quest | SubQuest | undefined {
+    const quest = this.findById(id);
     if (!quest) {
       logger.debug("quests:state", "update-not-found", { id });
       return undefined;
@@ -155,33 +312,127 @@ export class QuestLog {
     logger.debug("quests:state", QUEST_ACTIONS.update, {
       id,
       description,
-      total: this.quests.length,
+      total: this.quests.length + this.subQuests.length,
     });
     return quest;
   }
 
-  delete(id: number): Quest | undefined {
+  delete(id: string): Quest | SubQuest | null | undefined {
     const index = this.quests.findIndex((q) => q.id === id);
-    if (index === -1) {
-      logger.debug("quests:state", "delete-not-found", { id });
+    if (index !== -1) {
+      const subs = this.getSubQuests(id);
+      if (subs.some((q) => !q.done)) {
+        logger.debug("quests:state", "delete-blocked-subquests", { id });
+        return null;
+      }
+      const [quest] = this.quests.splice(index, 1);
+      this.usedIds.delete(quest.id);
+      const cascadeDeletedSubs = this.subQuests.filter((sq) => sq.parentId === id);
+      this.history.push({ type: QUEST_ACTIONS.delete, quest, index, cascadeDeletedSubs });
+      this.subQuests = this.subQuests.filter((sq) => {
+        if (sq.parentId === id) {
+          this.usedIds.delete(sq.id);
+          return false;
+        }
+        return true;
+      });
+      logger.debug("quests:state", QUEST_ACTIONS.delete, {
+        id,
+        index,
+        total: this.quests.length + this.subQuests.length,
+      });
+      return quest;
+    }
+    const subIndex = this.subQuests.findIndex((sq) => sq.id === id);
+    if (subIndex !== -1) {
+      const [quest] = this.subQuests.splice(subIndex, 1);
+      this.usedIds.delete(quest.id);
+      this.history.push({ type: QUEST_ACTIONS.delete, quest, index: subIndex, isSubQuest: true });
+      logger.debug("quests:state", QUEST_ACTIONS.delete, {
+        id,
+        index: subIndex,
+        total: this.quests.length + this.subQuests.length,
+      });
+      return quest;
+    }
+    logger.debug("quests:state", "delete-not-found", { id });
+    return undefined;
+  }
+
+  clear(all = false): number {
+    if (!all) {
+      const doneParentIds = new Set(this.quests.filter((q) => q.done).map((q) => q.id));
+      const done = this.quests.filter((q) => q.done);
+      const removedSubs = this.subQuests.filter((sq) => sq.done || doneParentIds.has(sq.parentId));
+      const keptSubs = this.subQuests.filter((sq) => !sq.done && !doneParentIds.has(sq.parentId));
+      const previousQuests = [...this.quests];
+      const previousSubQuests = [...this.subQuests];
+      for (const q of done) this.usedIds.delete(q.id);
+      for (const q of removedSubs) this.usedIds.delete(q.id);
+      this.quests = this.quests.filter((q) => !q.done);
+      this.subQuests = keptSubs;
+      this.history.push({
+        type: QUEST_ACTIONS.clear,
+        previousQuests,
+        previousSubQuests,
+        all: false,
+      });
+      const count = done.length + removedSubs.length;
+      logger.debug("quests:state", QUEST_ACTIONS.clear, { count, all });
+      return count;
+    }
+    const count = this.quests.length + this.subQuests.length;
+    this.history.push({
+      type: QUEST_ACTIONS.clear,
+      quests: [...this.quests],
+      subQuests: [...this.subQuests],
+      all: true,
+    });
+    this.quests = [];
+    this.subQuests = [];
+    this.usedIds.clear();
+    logger.debug("quests:state", QUEST_ACTIONS.clear, { count, all });
+    return count;
+  }
+
+  reorder(id: string, targetId: string): Quest | undefined {
+    if (this.subQuests.some((sq) => sq.id === id || sq.id === targetId)) {
+      logger.debug("quests:state", "reorder-subquest-rejected", { id, targetId });
+      return undefined;
+    }
+    const idx = this.quests.findIndex((q) => q.id === id);
+    if (idx === -1) {
+      logger.debug("quests:state", "reorder-not-found", { id });
       return undefined;
     }
 
-    const [quest] = this.quests.splice(index, 1);
-    this.history.push({ type: QUEST_ACTIONS.delete, quest, index });
+    const targetIdx = this.quests.findIndex((q) => q.id === targetId);
+    if (targetIdx === -1) {
+      logger.debug("quests:state", "reorder-target-not-found", { id, targetId });
+      return undefined;
+    }
 
-    logger.debug("quests:state", QUEST_ACTIONS.delete, { id, index, total: this.quests.length });
-    return quest;
-  }
+    if (idx === targetIdx) {
+      return this.quests[idx];
+    }
 
-  clear(): number {
-    const count = this.quests.length;
-    this.history.push({ type: QUEST_ACTIONS.clear, quests: [...this.quests], nextId: this.nextId });
-    this.quests = [];
-    this.nextId = 1;
+    const previousIds = this.quests.map((q) => q.id);
+    const [quest] = this.quests.splice(idx, 1);
 
-    logger.debug("quests:state", QUEST_ACTIONS.clear, { count });
-    return count;
+    let insertIndex = targetIdx;
+    if (idx < targetIdx) {
+      insertIndex = targetIdx - 1;
+    }
+
+    this.quests.splice(insertIndex, 0, quest);
+    this.history.push({ type: QUEST_ACTIONS.reorder, quest, oldIndex: idx, previousIds, targetId });
+    logger.debug("quests:state", QUEST_ACTIONS.reorder, {
+      id: quest.id,
+      targetId,
+      total: this.quests.length + this.subQuests.length,
+    });
+
+    return quest;
   }
 
   revert(): QuestOperationResult {
@@ -216,13 +467,53 @@ export class QuestLog {
               message: "Error: all descriptions in a batch must be non-empty",
             };
           }
-          const added: { id: number; description: string }[] = [];
-          for (const desc of action.descriptions) {
-            const q = this.add(desc);
-            added.push({ id: q.id, description: q.description });
+          if (action.parentId) {
+            if (this.subQuests.some((sq) => sq.id === action.parentId)) {
+              return {
+                success: false,
+                message: formatSubQuestCannotHaveSubQuests(action.parentId),
+              };
+            }
+            const parent = this.quests.find((q) => q.id === action.parentId);
+            if (!parent) {
+              return { success: false, message: formatNotFound(action.parentId) };
+            }
+            if (parent.done) {
+              return {
+                success: false,
+                message: `Error: cannot add sub-quest to completed parent quest [${action.parentId}]`,
+              };
+            }
+          }
+          if (action.descriptions.length === 1) {
+            try {
+              const [firstDesc] = action.descriptions;
+              const q = action.parentId
+                ? this.addSubQuest(firstDesc, action.parentId)
+                : this.add(firstDesc);
+
+              return { success: true, message: formatAddResult(q) };
+            } catch (err) {
+              return {
+                success: false,
+                message: `Error: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+          try {
+            const added: { id: string; description: string }[] = [];
+            for (const desc of action.descriptions) {
+              const q = action.parentId ? this.addSubQuest(desc, action.parentId) : this.add(desc);
+              added.push({ id: q.id, description: q.description });
+            }
+
+            return { success: true, message: formatBatchAddResult(added) };
+          } catch (err) {
+            return {
+              success: false,
+              message: `Error: ${err instanceof Error ? err.message : String(err)}`,
+            };
           }
-
-          return { success: true, message: formatBatchAddResult(added) };
         }
         return {
           success: false,
@@ -239,9 +530,12 @@ export class QuestLog {
         }
 
         const q = this.toggle(action.id);
-        if (!q) {
+        if (q === undefined) {
           return { success: false, message: formatNotFound(action.id) };
         }
+        if (q === null) {
+          return { success: false, message: formatBlockedBySubQuests(action.id) };
+        }
 
         return { success: true, message: formatToggleResult(action.id, q.done), quest: q };
       }
@@ -250,7 +544,7 @@ export class QuestLog {
           return { success: false, message: "Error: id is required for update action" };
         }
 
-        if (!action.description) {
+        if (!action.description || action.description.trim().length === 0) {
           return { success: false, message: "Error: description is required for update action" };
         }
 
@@ -267,15 +561,34 @@ export class QuestLog {
         }
 
         const q = this.delete(action.id);
-        if (!q) {
+        if (q === undefined) {
           return { success: false, message: formatNotFound(action.id) };
         }
+        if (q === null) {
+          return { success: false, message: formatBlockedBySubQuests(action.id) };
+        }
 
         return { success: true, message: formatDeleteResult(q), quest: q };
       }
       case QUEST_ACTIONS.clear: {
-        const count = this.clear();
-        return { success: true, message: formatClearResult(count) };
+        const count = this.clear(action.all);
+        const message = action.all
+          ? `Cleared ${count} quests`
+          : `Cleared ${count} completed quests`;
+
+        return { success: true, message };
+      }
+      case QUEST_ACTIONS.reorder: {
+        if (action.id === undefined)
+          return { success: false, message: "Error: id is required for reorder action" };
+
+        if (action.targetId === undefined)
+          return { success: false, message: "Error: targetId is required for reorder action" };
+
+        const q = this.reorder(action.id, action.targetId);
+        if (!q) return { success: false, message: "Quest not found or is a sub-quest" };
+
+        return { success: true, message: `Reordered quest [${q.id}]: ${q.description}`, quest: q };
       }
       case QUEST_ACTIONS.revert: {
         return this.revert();
@@ -305,15 +618,23 @@ export class QuestLog {
 
     if (lastState) {
       const quests = lastState.quests;
-      const nextId = lastState.nextId;
       const questCount = Array.isArray(quests) ? quests.length : 0;
 
-      this.quests = Array.isArray(quests) ? [...(quests as Quest[])] : [];
-      this.nextId = typeof nextId === "number" ? nextId : 1;
-      logger.debug("quests:state", "reconstruct", { toolResults, questCount, nextId: this.nextId });
+      if (Array.isArray(quests)) {
+        this.quests = (quests as Quest[]).filter((q) => !("parentId" in q && q.parentId));
+        this.subQuests = (quests as Quest[]).filter(
+          (q) => "parentId" in q && q.parentId,
+        ) as unknown as SubQuest[];
+      } else {
+        this.quests = [];
+        this.subQuests = [];
+      }
+      this.usedIds = new Set([...this.quests, ...this.subQuests].map((q) => q.id));
+      logger.debug("quests:state", "reconstruct", { toolResults, questCount });
     } else {
       this.quests = [];
-      this.nextId = 1;
+      this.subQuests = [];
+      this.usedIds.clear();
       logger.debug("quests:state", "reconstruct-empty", { toolResults });
     }
 
@@ -330,7 +651,7 @@ export function makeToolResult(
     content: [{ type: "text", text }],
     details: {
       quests: questLog.getAll(),
-      nextId: questLog.getNextId(),
+      usedIds: questLog.getUsedIds(),
       displayQuests,
     },
   };