@geanatz/cortex-mcp 5.0.1

package/dist/features/task-management/models/task.js

@@ -0,0 +1,84 @@
+/**
+ * Task data model for the task management system
+ * ID = folder name (e.g., '001-implement-auth') - acts as the task title
+ * Details = comprehensive description
+ *
+ * New Structure:
+ * - Each parent task has its own folder
+ * - Subtasks are stored INSIDE the parent .task.json file
+ * - No separate folders for subtasks
+ * - No dependsOn field - simplified dependency model
+ */
+/**
+ * Valid task status values
+ */
+export const TASK_STATUSES = ['pending', 'in_progress', 'done'];
+/**
+ * Status display information
+ */
+export const TASK_STATUS_INFO = {
+    pending: { label: 'Pending', icon: '⏳', description: 'Task has not been started' },
+    in_progress: { label: 'In Progress', icon: '🔄', description: 'Task is currently being worked on' },
+    done: { label: 'Done', icon: '✅', description: 'Task has been completed' },
+};
+/**
+ * Check if a status is valid
+ */
+export function isValidTaskStatus(status) {
+    return typeof status === 'string' && TASK_STATUSES.includes(status);
+}
+/**
+ * Get status icon
+ */
+export function getStatusIcon(status) {
+    return TASK_STATUS_INFO[status].icon;
+}
+/**
+ * Get status label
+ */
+export function getStatusLabel(status) {
+    return TASK_STATUS_INFO[status].label;
+}
+/**
+ * Check if task is done (including all subtasks)
+ */
+export function isTaskDone(task) {
+    if (task.status !== 'done')
+        return false;
+    if (task.subtasks.length === 0)
+        return true;
+    return task.subtasks.every(subtask => subtask.status === 'done');
+}
+/**
+ * Calculate task progress (ratio of done subtasks)
+ */
+export function calculateTaskProgress(task) {
+    if (task.subtasks.length === 0) {
+        return task.status === 'done' ? 1 : 0;
+    }
+    const doneCount = task.subtasks.filter(s => s.status === 'done').length;
+    return doneCount / task.subtasks.length;
+}
+/**
+ * Generate next subtask ID
+ */
+export function generateNextSubtaskId(subtasks) {
+    if (subtasks.length === 0)
+        return '1';
+    const maxId = Math.max(...subtasks.map(s => parseInt(s.id, 10)).filter(n => !isNaN(n)));
+    return String(maxId + 1);
+}
+/**
+ * Find subtask by ID
+ */
+export function findSubtask(task, subtaskId) {
+    return task.subtasks.find(s => s.id === subtaskId);
+}
+/**
+ * Check if all subtasks are done
+ */
+export function areAllSubtasksDone(task) {
+    if (task.subtasks.length === 0)
+        return true;
+    return task.subtasks.every(s => s.status === 'done');
+}

package/dist/features/task-management/storage/file-storage.d.ts

@@ -0,0 +1,130 @@
+import { BaseStorage, StorageStats } from './storage.js';
+import { Task, TaskHierarchy, CreateTaskInput, UpdateTaskInput, Subtask, AddSubtaskInput, UpdateSubtaskInput } from '../models/task.js';
+import { Artifact, CreateArtifactInput, UpdateArtifactInput, ArtifactPhase, TaskArtifacts } from '../models/artifact.js';
+/**
+ * File-based storage implementation - Simplified Model
+ *
+ * Storage Structure:
+ * - .cortex/tasks/{number}-{slug}/.task.json - Contains parent task + subtasks array
+ * - .cortex/tasks/{number}-{slug}/{phase}.md - Artifact files (for entire hierarchy)
+ *
+ * Key Changes:
+ * - Subtasks are stored INSIDE the parent .task.json file
+ * - No separate folders for subtasks
+ * - No dependsOn field - simplified model
+ * - Single level nesting only (subtasks cannot have subtasks)
+ * - Artifacts belong to the entire task hierarchy
+ *
+ * Features:
+ * - Each parent task has its own folder with sequential numbering
+ * - Task ID = folder name (e.g., '001-implement-auth')
+ * - Atomic file writes using temp files
+ * - In-memory caching with TTL
+ */
+export declare class FileStorage extends BaseStorage {
+    private readonly workingDirectory;
+    private readonly cortexDir;
+    private readonly tasksDir;
+    private readonly taskCache;
+    private readonly artifactCache;
+    private taskFoldersCache;
+    private taskFoldersCacheTime;
+    constructor(workingDirectory: string);
+    /**
+     * Initialize storage by validating working directory and ensuring directories exist
+     */
+    initialize(): Promise<void>;
+    getWorkingDirectory(): string;
+    /**
+     * Sanitize a string for safe filesystem usage
+     */
+    private sanitizeName;
+    /**
+     * Get the next sequential number by scanning existing task folders
+     */
+    private getNextNumber;
+    /**
+     * Generate task ID (folder name) from details
+     */
+    private generateTaskId;
+    /**
+     * Get task folder path
+     */
+    private getTaskFolderPath;
+    /**
+     * Get task file path
+     */
+    private getTaskFilePath;
+    /**
+     * Get artifact file path
+     */
+    private getArtifactFilePath;
+    /**
+     * Get all task folder names (parent tasks only, with caching)
+     */
+    private getTaskFolders;
+    /**
+     * Invalidate task folders cache
+     */
+    private invalidateTaskFoldersCache;
+    /**
+     * Load a task from disk (with caching)
+     */
+    private loadTask;
+    /**
+     * Save a task to disk and update cache
+     */
+    private saveTask;
+    /**
+     * Get all parent tasks (subtasks are inside each task)
+     */
+    getTasks(): Promise<readonly Task[]>;
+    /**
+     * Get a single task by ID
+     */
+    getTask(id: string): Promise<Task | null>;
+    /**
+     * Create a new parent task
+     */
+    createTask(input: CreateTaskInput): Promise<Task>;
+    /**
+     * Update an existing task
+     * Supports updating parent fields and subtask operations
+     */
+    updateTask(id: string, updates: UpdateTaskInput): Promise<Task | null>;
+    /**
+     * Delete a task and all its subtasks
+     */
+    deleteTask(id: string): Promise<boolean>;
+    /**
+     * Add a subtask to a parent task
+     */
+    addSubtask(taskId: string, input: AddSubtaskInput): Promise<Subtask | null>;
+    /**
+     * Update a subtask
+     */
+    updateSubtask(taskId: string, input: UpdateSubtaskInput): Promise<Subtask | null>;
+    /**
+     * Remove a subtask by ID
+     */
+    removeSubtask(taskId: string, subtaskId: string): Promise<boolean>;
+    /**
+     * Get task hierarchy (all parent tasks with their subtasks)
+     */
+    getTaskHierarchy(): Promise<readonly TaskHierarchy[]>;
+    /**
+     * Parse artifact file content (YAML frontmatter + markdown body)
+     */
+    private parseArtifactContent;
+    /**
+     * Serialize artifact to file content
+     */
+    private serializeArtifact;
+    getArtifact(taskId: string, phase: ArtifactPhase): Promise<Artifact | null>;
+    getAllArtifacts(taskId: string): Promise<TaskArtifacts>;
+    createArtifact(taskId: string, phase: ArtifactPhase, input: CreateArtifactInput): Promise<Artifact>;
+    updateArtifact(taskId: string, phase: ArtifactPhase, input: UpdateArtifactInput): Promise<Artifact | null>;
+    deleteArtifact(taskId: string, phase: ArtifactPhase): Promise<boolean>;
+    getStats(): Promise<StorageStats>;
+    clearCache(): void;
+}