@gitgov/core 1.0.2 → 1.2.0

package/dist/src/index.d.ts

@@ -1763,13 +1763,17 @@ interface IBacklogAdapter {
     updateTask(taskId: string, payload: Partial<TaskRecord>): Promise<TaskRecord>;
     activateTask(taskId: string, actorId: string): Promise<TaskRecord>;
     completeTask(taskId: string, actorId: string): Promise<TaskRecord>;
+    pauseTask(taskId: string, actorId: string, reason?: string): Promise<TaskRecord>;
     resumeTask(taskId: string, actorId: string, force?: boolean): Promise<TaskRecord>;
     discardTask(taskId: string, actorId: string, reason?: string): Promise<TaskRecord>;
+    deleteTask(taskId: string, actorId: string): Promise<void>;
     createCycle(payload: Partial<CycleRecord>, actorId: string): Promise<CycleRecord>;
     getCycle(cycleId: string): Promise<CycleRecord | null>;
     getAllCycles(): Promise<CycleRecord[]>;
     updateCycle(cycleId: string, payload: Partial<CycleRecord>): Promise<CycleRecord>;
     addTaskToCycle(cycleId: string, taskId: string): Promise<void>;
+    removeTasksFromCycle(cycleId: string, taskIds: string[]): Promise<void>;
+    moveTasksBetweenCycles(targetCycleId: string, taskIds: string[], sourceCycleId: string): Promise<void>;
     getTasksAssignedToActor(actorId: string): Promise<TaskRecord[]>;
     handleFeedbackCreated(event: FeedbackCreatedEvent): Promise<void>;
     handleFeedbackResolved(event: FeedbackStatusChangedEvent): Promise<void>;
@@ -1845,6 +1849,10 @@ declare class BacklogAdapter implements IBacklogAdapter {
      * Activates a task transitioning from ready to active with permission validation
      */
     activateTask(taskId: string, actorId: string): Promise<TaskRecord>;
+    /**
+     * Pauses a task manually transitioning from active to paused with optional reason
+     */
+    pauseTask(taskId: string, actorId: string, reason?: string): Promise<TaskRecord>;
     /**
      * Resumes a paused task transitioning back to active with optional force override
      */
@@ -1858,6 +1866,11 @@ declare class BacklogAdapter implements IBacklogAdapter {
      * Supports both cancellation (ready/active) and rejection (review) operations
      */
     discardTask(taskId: string, actorId: string, reason?: string): Promise<TaskRecord>;
+    /**
+     * Deletes a draft task completely (no discarded state)
+     * Only works for tasks in 'draft' status that never entered formal workflow
+     */
+    deleteTask(taskId: string, actorId: string): Promise<void>;
     /**
      * Updates a task with new payload
      */
@@ -1926,6 +1939,17 @@ declare class BacklogAdapter implements IBacklogAdapter {
      * Creates bidirectional link between task and cycle
      */
     addTaskToCycle(cycleId: string, taskId: string): Promise<void>;
+    /**
+     * Removes multiple tasks from a cycle with bidirectional unlinking
+     * All business logic and validation happens here in the adapter
+     */
+    removeTasksFromCycle(cycleId: string, taskIds: string[]): Promise<void>;
+    /**
+     * Moves multiple tasks from one cycle to another atomically
+     * Provides transactional semantics - all tasks move or none do
+     * All business logic and validation happens here in the adapter
+     */
+    moveTasksBetweenCycles(targetCycleId: string, taskIds: string[], sourceCycleId: string): Promise<void>;
     lint(): Promise<LintReport>;
     audit(): Promise<AuditReport>;
     processChanges(_changes: unknown[]): Promise<ExecutionRecord[]>;
@@ -5405,7 +5429,7 @@ declare class DiagramGenerator {
         cycleId?: string;
         taskId?: string;
         packageName?: string;
-    }): Promise<string>;
+    }, showArchived?: boolean): Promise<string>;
     /**
      * Convenience method to generate from .gitgov/ directory
      */
@@ -5413,7 +5437,7 @@ declare class DiagramGenerator {
         cycleId?: string;
         taskId?: string;
         packageName?: string;
-    }): Promise<string>;
+    }, showArchived?: boolean): Promise<string>;
     /**
      * Loads all cycle records from the filesystem
      */

package/dist/src/index.js

@@ -4236,6 +4236,55 @@ var BacklogAdapter = class {
     });
     return updatedPayload;
   }
+  /**
+   * Pauses a task manually transitioning from active to paused with optional reason
+   */
+  async pauseTask(taskId, actorId, reason) {
+    const taskRecord = await this.taskStore.read(taskId);
+    if (!taskRecord) {
+      throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
+    }
+    const task = taskRecord.payload;
+    if (task.status !== "active") {
+      throw new Error(`ProtocolViolationError: Task is in '${task.status}' state. Cannot pause (requires active).`);
+    }
+    const actor = await this.getActor(actorId);
+    const context = {
+      task,
+      actor,
+      signatures: taskRecord.header.signatures,
+      transitionTo: "paused"
+    };
+    const transitionRule = await this.workflowMethodologyAdapter.getTransitionRule("active", "paused", context);
+    if (!transitionRule) {
+      throw new Error("ProtocolViolationError: Workflow methodology rejected active\u2192paused transition");
+    }
+    const updatedPayload = {
+      ...task,
+      status: "paused",
+      // Add reason to notes with [PAUSED] prefix if provided
+      ...reason && {
+        notes: `${task.notes || ""}
+[PAUSED] ${reason} (${(/* @__PURE__ */ new Date()).toISOString()})`.trim()
+      }
+    };
+    const updatedRecord = { ...taskRecord, payload: updatedPayload };
+    const signedRecord = await this.identity.signRecord(updatedRecord, actorId, "pauser");
+    await this.taskStore.write(signedRecord);
+    this.eventBus.publish({
+      type: "task.status.changed",
+      timestamp: Date.now(),
+      source: "backlog_adapter",
+      payload: {
+        taskId,
+        oldStatus: "active",
+        newStatus: "paused",
+        actorId,
+        reason: reason || "Task manually paused"
+      }
+    });
+    return updatedPayload;
+  }
   /**
    * Resumes a paused task transitioning back to active with optional force override
    */
@@ -4334,6 +4383,9 @@ var BacklogAdapter = class {
     const task = taskRecord.payload;
     const actor = await this.getActor(actorId);
     if (!["ready", "active", "review"].includes(task.status)) {
+      if (task.status === "draft") {
+        throw new Error(`ProtocolViolationError: Cannot cancel task in 'draft' state. Use 'gitgov task delete ${taskId}' to remove draft tasks.`);
+      }
       throw new Error(`ProtocolViolationError: Task is in '${task.status}' state. Cannot cancel from this state. Only 'ready', 'active', and 'review' tasks can be cancelled.`);
     }
     const context = {
@@ -4372,6 +4424,39 @@ ${task.status === "review" ? "[REJECTED]" : "[CANCELLED]"} ${reason} (${(/* @__P
     });
     return updatedPayload;
   }
+  /**
+   * Deletes a draft task completely (no discarded state)
+   * Only works for tasks in 'draft' status that never entered formal workflow
+   */
+  async deleteTask(taskId, actorId) {
+    const taskRecord = await this.taskStore.read(taskId);
+    if (!taskRecord) {
+      throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
+    }
+    const task = taskRecord.payload;
+    if (task.status !== "draft") {
+      if (task.status === "review") {
+        throw new Error(`ProtocolViolationError: Cannot delete task in 'review' state. Use 'gitgov task reject ${taskId}' to discard tasks under review.`);
+      } else if (task.status === "ready" || task.status === "active") {
+        throw new Error(`ProtocolViolationError: Cannot delete task in '${task.status}' state. Use 'gitgov task cancel ${taskId}' to discard tasks from ready/active states.`);
+      }
+      throw new Error(`ProtocolViolationError: Cannot delete task in '${task.status}' state. Only draft tasks can be deleted.`);
+    }
+    await this.getActor(actorId);
+    await this.taskStore.delete(taskId);
+    this.eventBus.publish({
+      type: "task.status.changed",
+      timestamp: Date.now(),
+      source: "backlog_adapter",
+      payload: {
+        taskId,
+        oldStatus: "draft",
+        newStatus: "deleted",
+        actorId,
+        reason: "Draft task deleted"
+      }
+    });
+  }
   /**
    * Updates a task with new payload
    */
@@ -4801,6 +4886,156 @@ ${task.status === "review" ? "[REJECTED]" : "[CANCELLED]"} ${reason} (${(/* @__P
       this.taskStore.write(signedTaskRecord)
     ]);
   }
+  /**
+   * Removes multiple tasks from a cycle with bidirectional unlinking
+   * All business logic and validation happens here in the adapter
+   */
+  async removeTasksFromCycle(cycleId, taskIds) {
+    if (!cycleId || typeof cycleId !== "string") {
+      throw new Error("ValidationError: cycleId must be a non-empty string");
+    }
+    if (!Array.isArray(taskIds) || taskIds.length === 0) {
+      throw new Error("ValidationError: taskIds must be a non-empty array");
+    }
+    const cycleRecord = await this.cycleStore.read(cycleId);
+    if (!cycleRecord) {
+      throw new Error(`RecordNotFoundError: Cycle not found: ${cycleId}`);
+    }
+    const taskRecords = await Promise.all(
+      taskIds.map(async (taskId) => {
+        const taskRecord = await this.taskStore.read(taskId);
+        if (!taskRecord) {
+          throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
+        }
+        return { taskId, record: taskRecord };
+      })
+    );
+    const cycleTaskIds = cycleRecord.payload.taskIds || [];
+    const notLinkedTasks = taskIds.filter((taskId) => !cycleTaskIds.includes(taskId));
+    if (notLinkedTasks.length > 0) {
+      throw new Error(`ValidationError: Tasks not linked to cycle ${cycleId}: ${notLinkedTasks.join(", ")}`);
+    }
+    const updatedCycle = {
+      ...cycleRecord.payload,
+      taskIds: cycleTaskIds.filter((id) => !taskIds.includes(id))
+    };
+    const currentActor = await this.identity.getCurrentActor();
+    const signedCycleRecord = await this.identity.signRecord(
+      { ...cycleRecord, payload: updatedCycle },
+      currentActor.id,
+      "author"
+    );
+    const signedTaskRecords = await Promise.all(
+      taskRecords.map(async ({ record }) => {
+        const taskCycleIds = record.payload.cycleIds || [];
+        const updatedTask = {
+          ...record.payload,
+          cycleIds: taskCycleIds.filter((id) => id !== cycleId)
+        };
+        return await this.identity.signRecord(
+          { ...record, payload: updatedTask },
+          currentActor.id,
+          "author"
+        );
+      })
+    );
+    await Promise.all([
+      this.cycleStore.write(signedCycleRecord),
+      ...signedTaskRecords.map(
+        (signedTask) => this.taskStore.write(signedTask)
+      )
+    ]);
+  }
+  /**
+   * Moves multiple tasks from one cycle to another atomically
+   * Provides transactional semantics - all tasks move or none do
+   * All business logic and validation happens here in the adapter
+   */
+  async moveTasksBetweenCycles(targetCycleId, taskIds, sourceCycleId) {
+    if (!sourceCycleId || typeof sourceCycleId !== "string") {
+      throw new Error("ValidationError: sourceCycleId must be a non-empty string");
+    }
+    if (!targetCycleId || typeof targetCycleId !== "string") {
+      throw new Error("ValidationError: targetCycleId must be a non-empty string");
+    }
+    if (!Array.isArray(taskIds) || taskIds.length === 0) {
+      throw new Error("ValidationError: taskIds must be a non-empty array");
+    }
+    if (sourceCycleId === targetCycleId) {
+      throw new Error("ValidationError: Source and target cycles must be different");
+    }
+    const [sourceCycleRecord, targetCycleRecord] = await Promise.all([
+      this.cycleStore.read(sourceCycleId),
+      this.cycleStore.read(targetCycleId)
+    ]);
+    if (!sourceCycleRecord) {
+      throw new Error(`RecordNotFoundError: Source cycle not found: ${sourceCycleId}`);
+    }
+    if (!targetCycleRecord) {
+      throw new Error(`RecordNotFoundError: Target cycle not found: ${targetCycleId}`);
+    }
+    const taskRecords = await Promise.all(
+      taskIds.map(async (taskId) => {
+        const taskRecord = await this.taskStore.read(taskId);
+        if (!taskRecord) {
+          throw new Error(`RecordNotFoundError: Task not found: ${taskId}`);
+        }
+        return { taskId, record: taskRecord };
+      })
+    );
+    const sourceTaskIds = sourceCycleRecord.payload.taskIds || [];
+    const notLinkedTasks = taskIds.filter((taskId) => !sourceTaskIds.includes(taskId));
+    if (notLinkedTasks.length > 0) {
+      throw new Error(`ValidationError: Tasks not linked to source cycle ${sourceCycleId}: ${notLinkedTasks.join(", ")}`);
+    }
+    const updatedSourceCycle = {
+      ...sourceCycleRecord.payload,
+      taskIds: sourceTaskIds.filter((id) => !taskIds.includes(id))
+    };
+    const updatedTargetCycle = {
+      ...targetCycleRecord.payload,
+      taskIds: [...targetCycleRecord.payload.taskIds || [], ...taskIds]
+    };
+    const currentActor = await this.identity.getCurrentActor();
+    const [signedSourceCycle, signedTargetCycle] = await Promise.all([
+      this.identity.signRecord(
+        { ...sourceCycleRecord, payload: updatedSourceCycle },
+        currentActor.id,
+        "author"
+      ),
+      this.identity.signRecord(
+        { ...targetCycleRecord, payload: updatedTargetCycle },
+        currentActor.id,
+        "author"
+      )
+    ]);
+    const signedTaskRecords = await Promise.all(
+      taskRecords.map(async ({ record }) => {
+        const taskCycleIds = record.payload.cycleIds || [];
+        const updatedTask = {
+          ...record.payload,
+          cycleIds: taskCycleIds.filter((id) => id !== sourceCycleId).concat(targetCycleId)
+          // Add target
+        };
+        return await this.identity.signRecord(
+          { ...record, payload: updatedTask },
+          currentActor.id,
+          "author"
+        );
+      })
+    );
+    try {
+      await Promise.all([
+        this.cycleStore.write(signedSourceCycle),
+        this.cycleStore.write(signedTargetCycle),
+        ...signedTaskRecords.map(
+          (signedTask) => this.taskStore.write(signedTask)
+        )
+      ]);
+    } catch (error) {
+      throw new Error(`AtomicOperationError: Failed to move tasks between cycles: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
   // TODO: Implement when lint_command.md is implemented
   async lint() {
     throw new Error("NotImplementedError: lint() will be implemented when lint_command.md is ready");
@@ -5442,7 +5677,18 @@ var ProjectAdapter = class {
         {
           type: "human",
           displayName: options.actorName || "Project Owner",
-          roles: ["admin", "author"]
+          roles: [
+            "admin",
+            // Platform admin (future use)
+            "author",
+            // Create & submit tasks
+            "approver:product",
+            // Approve tasks (product decisions)
+            "approver:quality",
+            // Complete tasks (quality validation)
+            "developer"
+            // General development work
+          ]
         },
         "bootstrap"
       );
@@ -5848,7 +6094,8 @@ var workflow_methodology_default_default = {
     },
     active: {
       from: [
-        "ready"
+        "ready",
+        "paused"
       ],
       requires: {
         event: "first_execution_record_created",
@@ -6018,7 +6265,8 @@ var workflow_methodology_scrum_default = {
     },
     active: {
       from: [
-        "ready"
+        "ready",
+        "paused"
       ],
       requires: {
         event: "sprint_started",
@@ -7714,8 +7962,8 @@ var DiagramGenerator = class {
   /**
    * Primary API - Performance optimized with caching
    */
-  async generateFromRecords(cycles, tasks, filters) {
-    const cacheKey = this.generateCacheKey(cycles, tasks);
+  async generateFromRecords(cycles, tasks, filters, showArchived = false) {
+    const cacheKey = this.generateCacheKey(cycles, tasks, showArchived);
     if (this.cache.has(cacheKey)) {
       this.metrics.incrementCacheHits();
       return this.renderFromCache(cacheKey);
@@ -7724,8 +7972,12 @@ var DiagramGenerator = class {
     try {
       let finalCycles = cycles;
       let finalTasks = tasks;
+      if (!showArchived) {
+        finalCycles = cycles.filter((cycle) => cycle.status !== "archived");
+        finalTasks = tasks.filter((task) => task.status !== "archived");
+      }
       if (filters && (filters.cycleId || filters.taskId || filters.packageName)) {
-        const filtered = this.analyzer.filterEntities(cycles, tasks, filters);
+        const filtered = this.analyzer.filterEntities(finalCycles, finalTasks, filters);
         finalCycles = filtered.filteredCycles;
         finalTasks = filtered.filteredTasks;
       }
@@ -7743,10 +7995,10 @@ var DiagramGenerator = class {
   /**
    * Convenience method to generate from .gitgov/ directory
    */
-  async generateFromFiles(gitgovPath = ".gitgov", filters) {
+  async generateFromFiles(gitgovPath = ".gitgov", filters, showArchived = false) {
     const cycles = await this.loadCycleRecords(gitgovPath);
     const tasks = await this.loadTaskRecords(gitgovPath);
-    return this.generateFromRecords(cycles, tasks, filters);
+    return this.generateFromRecords(cycles, tasks, filters, showArchived);
   }
   /**
    * Loads all cycle records from the filesystem
@@ -7830,13 +8082,14 @@ var DiagramGenerator = class {
   /**
    * Generates cache key for efficient lookups
    */
-  generateCacheKey(cycles, tasks) {
+  generateCacheKey(cycles, tasks, showArchived = false) {
     const cycleIds = [...new Set(cycles.map((c) => c.id))].sort();
     const taskIds = [...new Set(tasks.map((t) => t.id))].sort();
     const cycleHash = this.hashArray(cycleIds);
     const taskHash = this.hashArray(taskIds);
     const optionsHash = this.hashString(JSON.stringify(this.options));
-    return `diagram:${cycleHash}-${taskHash}-${optionsHash}`;
+    const archivedFlag = showArchived ? "with-archived" : "no-archived";
+    return `diagram:${cycleHash}-${taskHash}-${optionsHash}-${archivedFlag}`;
   }
   /**
    * Efficient hash function for arrays