specweave 0.16.11 → 0.16.12

package/dist/core/increment/metadata-manager.js

@@ -1,335 +0,0 @@
-/**
- * Metadata Manager
- *
- * Handles CRUD operations for increment metadata (status, type, timestamps).
- * Part of increment 0007: Smart Status Management
- */
-import fs from 'fs-extra';
-import path from 'path';
-import { IncrementStatus, IncrementType, createDefaultMetadata, isValidTransition, isStale, shouldAutoAbandon } from '../types/increment-metadata.js';
-import { ActiveIncrementManager } from './active-increment-manager.js';
-/**
- * Error thrown when metadata operations fail
- */
-export class MetadataError extends Error {
-    constructor(message, incrementId, cause) {
-        super(message);
-        this.incrementId = incrementId;
-        this.cause = cause;
-        this.name = 'MetadataError';
-    }
-}
-/**
- * Metadata Manager
- *
- * Provides CRUD operations and queries for increment metadata
- */
-export class MetadataManager {
-    /**
-     * Get metadata file path for increment
-     */
-    static getMetadataPath(incrementId) {
-        const specweavePath = path.join(process.cwd(), '.specweave');
-        return path.join(specweavePath, 'increments', incrementId, 'metadata.json');
-    }
-    /**
-     * Get increment directory path
-     */
-    static getIncrementPath(incrementId) {
-        const specweavePath = path.join(process.cwd(), '.specweave');
-        return path.join(specweavePath, 'increments', incrementId);
-    }
-    /**
-     * Check if metadata file exists
-     */
-    static exists(incrementId) {
-        const metadataPath = this.getMetadataPath(incrementId);
-        return fs.existsSync(metadataPath);
-    }
-    /**
-     * Read metadata from file
-     * Creates default metadata if file doesn't exist (lazy initialization)
-     */
-    static read(incrementId) {
-        const metadataPath = this.getMetadataPath(incrementId);
-        // Lazy initialization: Create metadata if doesn't exist
-        if (!fs.existsSync(metadataPath)) {
-            // Check if increment folder exists
-            const incrementPath = this.getIncrementPath(incrementId);
-            if (!fs.existsSync(incrementPath)) {
-                throw new MetadataError(`Increment not found: ${incrementId}`, incrementId);
-            }
-            // Create default metadata
-            const defaultMetadata = createDefaultMetadata(incrementId);
-            this.write(incrementId, defaultMetadata);
-            return defaultMetadata;
-        }
-        try {
-            const content = fs.readFileSync(metadataPath, 'utf-8');
-            const metadata = JSON.parse(content);
-            // Validate schema
-            this.validate(metadata);
-            return metadata;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new MetadataError(`Failed to read metadata for ${incrementId}: ${errorMessage}`, incrementId, error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    /**
-     * Write metadata to file
-     * Uses atomic write (temp file → rename)
-     */
-    static write(incrementId, metadata) {
-        const metadataPath = this.getMetadataPath(incrementId);
-        const incrementPath = this.getIncrementPath(incrementId);
-        // Ensure increment directory exists
-        if (!fs.existsSync(incrementPath)) {
-            throw new MetadataError(`Increment directory not found: ${incrementId}`, incrementId);
-        }
-        try {
-            // Validate before writing
-            this.validate(metadata);
-            // Atomic write: temp file → rename
-            const tempPath = `${metadataPath}.tmp`;
-            fs.writeFileSync(tempPath, JSON.stringify(metadata, null, 2), 'utf-8');
-            fs.renameSync(tempPath, metadataPath);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new MetadataError(`Failed to write metadata for ${incrementId}: ${errorMessage}`, incrementId, error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    /**
-     * Delete metadata file
-     */
-    static delete(incrementId) {
-        const metadataPath = this.getMetadataPath(incrementId);
-        if (!fs.existsSync(metadataPath)) {
-            return; // Already deleted
-        }
-        try {
-            fs.unlinkSync(metadataPath);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new MetadataError(`Failed to delete metadata for ${incrementId}: ${errorMessage}`, incrementId, error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    /**
-     * Update increment status
-     * Validates transition and updates timestamps
-     *
-     * **CRITICAL**: Also updates active increment state automatically!
-     */
-    static updateStatus(incrementId, newStatus, reason) {
-        const metadata = this.read(incrementId);
-        // Validate transition
-        if (!isValidTransition(metadata.status, newStatus)) {
-            throw new MetadataError(`Invalid status transition: ${metadata.status} → ${newStatus}`, incrementId);
-        }
-        // Update status
-        metadata.status = newStatus;
-        metadata.lastActivity = new Date().toISOString();
-        // Update status-specific fields
-        if (newStatus === IncrementStatus.PAUSED) {
-            metadata.pausedReason = reason || 'No reason provided';
-            metadata.pausedAt = new Date().toISOString();
-        }
-        else if (newStatus === IncrementStatus.ACTIVE) {
-            // Clear paused fields when resuming
-            metadata.pausedReason = undefined;
-            metadata.pausedAt = undefined;
-        }
-        else if (newStatus === IncrementStatus.ABANDONED) {
-            metadata.abandonedReason = reason || 'No reason provided';
-            metadata.abandonedAt = new Date().toISOString();
-        }
-        this.write(incrementId, metadata);
-        // **CRITICAL**: Update active increment state
-        const activeManager = new ActiveIncrementManager();
-        if (newStatus === IncrementStatus.ACTIVE) {
-            // Increment became active → set as active
-            activeManager.setActive(incrementId);
-        }
-        else if (newStatus === IncrementStatus.COMPLETED ||
-            newStatus === IncrementStatus.PAUSED ||
-            newStatus === IncrementStatus.ABANDONED) {
-            // Increment no longer active → smart update (find next active or clear)
-            activeManager.smartUpdate();
-        }
-        return metadata;
-    }
-    /**
-     * Update increment type
-     */
-    static updateType(incrementId, type) {
-        const metadata = this.read(incrementId);
-        metadata.type = type;
-        metadata.lastActivity = new Date().toISOString();
-        this.write(incrementId, metadata);
-        return metadata;
-    }
-    /**
-     * Touch increment (update lastActivity)
-     */
-    static touch(incrementId) {
-        const metadata = this.read(incrementId);
-        metadata.lastActivity = new Date().toISOString();
-        this.write(incrementId, metadata);
-        return metadata;
-    }
-    /**
-     * Get all increments
-     */
-    static getAll() {
-        const incrementsPath = path.join(process.cwd(), '.specweave', 'increments');
-        if (!fs.existsSync(incrementsPath)) {
-            return [];
-        }
-        const incrementFolders = fs.readdirSync(incrementsPath)
-            .filter(name => {
-            const folderPath = path.join(incrementsPath, name);
-            return fs.statSync(folderPath).isDirectory() && !name.startsWith('_');
-        });
-        return incrementFolders
-            .map(folder => {
-            try {
-                return this.read(folder);
-            }
-            catch (error) {
-                // Skip increments with invalid/missing metadata
-                return null;
-            }
-        })
-            .filter((m) => m !== null);
-    }
-    /**
-     * Get increments by status
-     */
-    static getByStatus(status) {
-        return this.getAll().filter(m => m.status === status);
-    }
-    /**
-     * Get active increments
-     */
-    static getActive() {
-        return this.getByStatus(IncrementStatus.ACTIVE);
-    }
-    /**
-     * Get paused increments
-     */
-    static getPaused() {
-        return this.getByStatus(IncrementStatus.PAUSED);
-    }
-    /**
-     * Get completed increments
-     */
-    static getCompleted() {
-        return this.getByStatus(IncrementStatus.COMPLETED);
-    }
-    /**
-     * Get abandoned increments
-     */
-    static getAbandoned() {
-        return this.getByStatus(IncrementStatus.ABANDONED);
-    }
-    /**
-     * Get increments by type
-     */
-    static getByType(type) {
-        return this.getAll().filter(m => m.type === type);
-    }
-    /**
-     * Get stale increments (paused >7 days or active >30 days)
-     */
-    static getStale() {
-        return this.getAll().filter(m => isStale(m));
-    }
-    /**
-     * Get increments that should be auto-abandoned (experiments inactive >14 days)
-     */
-    static getShouldAutoAbandon() {
-        return this.getAll().filter(m => shouldAutoAbandon(m));
-    }
-    /**
-     * Get extended metadata with computed fields (progress, age, etc.)
-     */
-    static getExtended(incrementId) {
-        const metadata = this.read(incrementId);
-        const extended = { ...metadata };
-        // Calculate progress from tasks.md
-        try {
-            const tasksPath = path.join(this.getIncrementPath(incrementId), 'tasks.md');
-            if (fs.existsSync(tasksPath)) {
-                const tasksContent = fs.readFileSync(tasksPath, 'utf-8');
-                // Count completed tasks: [x] or [X]
-                const completedMatches = tasksContent.match(/\[x\]/gi);
-                extended.completedTasks = completedMatches ? completedMatches.length : 0;
-                // Count total tasks: [ ] or [x]
-                const totalMatches = tasksContent.match(/\[ \]|\[x\]/gi);
-                extended.totalTasks = totalMatches ? totalMatches.length : 0;
-                // Calculate progress percentage
-                if (extended.totalTasks > 0) {
-                    extended.progress = Math.round((extended.completedTasks / extended.totalTasks) * 100);
-                }
-            }
-        }
-        catch (error) {
-            // Ignore errors reading tasks.md
-        }
-        // Calculate age in days
-        const now = new Date();
-        const createdDate = new Date(metadata.created);
-        extended.ageInDays = Math.floor((now.getTime() - createdDate.getTime()) / (1000 * 60 * 60 * 24));
-        // Calculate days paused
-        if (metadata.status === IncrementStatus.PAUSED && metadata.pausedAt) {
-            const pausedDate = new Date(metadata.pausedAt);
-            extended.daysPaused = Math.floor((now.getTime() - pausedDate.getTime()) / (1000 * 60 * 60 * 24));
-        }
-        return extended;
-    }
-    /**
-     * Validate metadata schema
-     */
-    static validate(metadata) {
-        if (!metadata.id) {
-            throw new Error('Metadata missing required field: id');
-        }
-        if (!metadata.status || !Object.values(IncrementStatus).includes(metadata.status)) {
-            throw new Error(`Invalid status: ${metadata.status}`);
-        }
-        if (!metadata.type || !Object.values(IncrementType).includes(metadata.type)) {
-            throw new Error(`Invalid type: ${metadata.type}`);
-        }
-        if (!metadata.created) {
-            throw new Error('Metadata missing required field: created');
-        }
-        if (!metadata.lastActivity) {
-            throw new Error('Metadata missing required field: lastActivity');
-        }
-        return true;
-    }
-    /**
-     * Check if status transition is allowed
-     */
-    static canTransition(from, to) {
-        return isValidTransition(from, to);
-    }
-    /**
-     * Get human-readable status transition error message
-     */
-    static getTransitionError(from, to) {
-        if (from === IncrementStatus.COMPLETED) {
-            return `Cannot transition from completed state. Increment is already complete.`;
-        }
-        if (to === IncrementStatus.PAUSED && from === IncrementStatus.ABANDONED) {
-            return `Cannot pause an abandoned increment. Resume it first with /resume.`;
-        }
-        if (to === IncrementStatus.COMPLETED && from === IncrementStatus.ABANDONED) {
-            return `Cannot complete an abandoned increment. Resume it first with /resume.`;
-        }
-        return `Invalid transition: ${from} → ${to}`;
-    }
-}
-//# sourceMappingURL=metadata-manager.js.map