project-iris 0.0.1

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/parser/dependencyComputation.ts

@@ -0,0 +1,157 @@
+/**
+ * Bolt dependency computation functions.
+ * Computes isBlocked, blockedBy, and unblocksCount for each bolt.
+ */
+
+import { Bolt, ArtifactStatus } from './types';
+
+/**
+ * Computes dependency state for all bolts.
+ * This must be called after all bolts are parsed to correctly determine
+ * blocked status based on the complete set of bolts.
+ *
+ * @param bolts - Array of parsed bolts (with requiresBolts and enablesBolts set)
+ * @returns Array of bolts with computed isBlocked, blockedBy, and unblocksCount
+ */
+export function computeBoltDependencies(bolts: Bolt[]): Bolt[] {
+    // Create a status lookup map for O(1) access
+    const boltStatusMap = new Map<string, ArtifactStatus>(
+        bolts.map(b => [b.id, b.status])
+    );
+
+    // Compute unblocksCount for each bolt (how many bolts require this one)
+    const unblocksCountMap = new Map<string, number>();
+    for (const bolt of bolts) {
+        for (const reqId of bolt.requiresBolts) {
+            const current = unblocksCountMap.get(reqId) || 0;
+            unblocksCountMap.set(reqId, current + 1);
+        }
+    }
+
+    return bolts.map(bolt => {
+        // Already completed bolts are never blocked
+        if (bolt.status === ArtifactStatus.Complete) {
+            return {
+                ...bolt,
+                isBlocked: false,
+                blockedBy: [],
+                unblocksCount: unblocksCountMap.get(bolt.id) || 0
+            };
+        }
+
+        // Check which required bolts are incomplete
+        const blockedBy = bolt.requiresBolts.filter(reqId => {
+            const status = boltStatusMap.get(reqId);
+            // If bolt doesn't exist or isn't complete, it's a blocker
+            return status !== ArtifactStatus.Complete;
+        });
+
+        const isBlocked = blockedBy.length > 0;
+
+        return {
+            ...bolt,
+            isBlocked,
+            blockedBy,
+            unblocksCount: unblocksCountMap.get(bolt.id) || 0,
+            // Update status to Blocked if appropriate
+            status: isBlocked && bolt.status === ArtifactStatus.Draft
+                ? ArtifactStatus.Blocked
+                : bolt.status
+        };
+    });
+}
+
+/**
+ * Gets pending bolts ordered by priority for the "Up Next" queue.
+ *
+ * Priority order:
+ * 1. Unblocked bolts first (can start immediately)
+ * 2. Among unblocked, prioritize by unblocksCount (enables more work)
+ * 3. Blocked bolts last
+ *
+ * @param bolts - Array of bolts with computed dependencies
+ * @returns Array of pending/blocked bolts sorted by priority
+ */
+export function getUpNextBolts(bolts: Bolt[]): Bolt[] {
+    return bolts
+        .filter(b =>
+            b.status === ArtifactStatus.Draft ||
+            b.status === ArtifactStatus.Blocked
+        )
+        .sort((a, b) => {
+            // Unblocked first
+            if (!a.isBlocked && b.isBlocked) {
+                return -1;
+            }
+            if (a.isBlocked && !b.isBlocked) {
+                return 1;
+            }
+
+            // Then by unblocksCount (more impact first)
+            if (b.unblocksCount !== a.unblocksCount) {
+                return b.unblocksCount - a.unblocksCount;
+            }
+
+            // Finally by ID for stable sorting
+            return a.id.localeCompare(b.id);
+        });
+}
+
+/**
+ * Checks if a specific bolt is blocked.
+ *
+ * @param bolt - The bolt to check
+ * @param allBolts - All bolts for status lookup
+ * @returns true if any required bolts are incomplete
+ */
+export function isBoltBlocked(bolt: Bolt, allBolts: Bolt[]): boolean {
+    if (bolt.status === ArtifactStatus.Complete) {
+        return false;
+    }
+
+    if (bolt.requiresBolts.length === 0) {
+        return false;
+    }
+
+    const boltStatusMap = new Map<string, ArtifactStatus>(
+        allBolts.map(b => [b.id, b.status])
+    );
+
+    return bolt.requiresBolts.some(reqId => {
+        const status = boltStatusMap.get(reqId);
+        return status !== ArtifactStatus.Complete;
+    });
+}
+
+/**
+ * Gets the list of bolts blocking a specific bolt.
+ *
+ * @param bolt - The bolt to check
+ * @param allBolts - All bolts for status lookup
+ * @returns Array of IDs of incomplete required bolts
+ */
+export function getBlockingBolts(bolt: Bolt, allBolts: Bolt[]): string[] {
+    if (bolt.status === ArtifactStatus.Complete) {
+        return [];
+    }
+
+    const boltStatusMap = new Map<string, ArtifactStatus>(
+        allBolts.map(b => [b.id, b.status])
+    );
+
+    return bolt.requiresBolts.filter(reqId => {
+        const status = boltStatusMap.get(reqId);
+        return status !== ArtifactStatus.Complete;
+    });
+}
+
+/**
+ * Counts how many bolts a specific bolt enables (unblocks).
+ *
+ * @param boltId - ID of the bolt
+ * @param allBolts - All bolts to check
+ * @returns Number of bolts that require this bolt
+ */
+export function countUnblocks(boltId: string, allBolts: Bolt[]): number {
+    return allBolts.filter(b => b.requiresBolts.includes(boltId)).length;
+}

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/parser/frontmatterParser.ts

@@ -0,0 +1,144 @@
+/**
+ * Frontmatter parsing utilities.
+ * Extracts YAML frontmatter from markdown files and normalizes status values.
+ */
+
+import * as yaml from 'js-yaml';
+import { ArtifactStatus, FrontmatterData } from './types';
+
+/**
+ * Regex to match YAML frontmatter at the start of a file.
+ * Matches content between --- delimiters.
+ */
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---/;
+
+/**
+ * Parses YAML frontmatter from a markdown file's content.
+ *
+ * @param content - The full file content
+ * @returns Parsed frontmatter object, or null if no valid frontmatter found
+ *
+ * @example
+ * ```typescript
+ * const content = `---
+ * status: in-progress
+ * priority: must
+ * ---
+ * # My Document`;
+ *
+ * const fm = parseFrontmatter(content);
+ * // { status: 'in-progress', priority: 'must' }
+ * ```
+ */
+export function parseFrontmatter(content: string): FrontmatterData | null {
+    if (!content || typeof content !== 'string') {
+        return null;
+    }
+
+    const match = content.match(FRONTMATTER_REGEX);
+    if (!match || !match[1]) {
+        return null;
+    }
+
+    try {
+        const parsed = yaml.load(match[1]);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed as FrontmatterData;
+        }
+        return null;
+    } catch (error) {
+        // Log warning but don't throw - graceful degradation
+        console.warn('Failed to parse YAML frontmatter:', error);
+        return null;
+    }
+}
+
+/**
+ * Normalizes a raw status string to ArtifactStatus enum.
+ * Handles common variations in status naming.
+ *
+ * @param rawStatus - The raw status string from frontmatter
+ * @returns Normalized ArtifactStatus
+ *
+ * @example
+ * ```typescript
+ * normalizeStatus('in-progress'); // ArtifactStatus.InProgress
+ * normalizeStatus('completed');   // ArtifactStatus.Complete
+ * normalizeStatus('pending');     // ArtifactStatus.Draft
+ * normalizeStatus('unknown');     // ArtifactStatus.Unknown
+ * ```
+ */
+export function normalizeStatus(rawStatus: string | undefined): ArtifactStatus {
+    if (!rawStatus || typeof rawStatus !== 'string') {
+        return ArtifactStatus.Unknown;
+    }
+
+    const normalized = rawStatus.toLowerCase().trim();
+
+    // Draft variations
+    if (['draft', 'pending', 'planned', 'todo', 'new'].includes(normalized)) {
+        return ArtifactStatus.Draft;
+    }
+
+    // In-progress variations
+    if ([
+        'in-progress',
+        'in_progress',
+        'inprogress',
+        'in progress',
+        'active',
+        'started',
+        'wip',
+        'working',
+        'ready',
+        'construction'
+    ].includes(normalized)) {
+        return ArtifactStatus.InProgress;
+    }
+
+    // Complete variations
+    if ([
+        'complete',
+        'completed',
+        'done',
+        'finished',
+        'closed',
+        'resolved'
+    ].includes(normalized)) {
+        return ArtifactStatus.Complete;
+    }
+
+    return ArtifactStatus.Unknown;
+}
+
+/**
+ * Extracts a specific field from frontmatter content.
+ *
+ * @param content - The full file content
+ * @param field - The field name to extract
+ * @returns The field value, or undefined if not found
+ */
+export function extractFrontmatterField<T = unknown>(
+    content: string,
+    field: string
+): T | undefined {
+    const frontmatter = parseFrontmatter(content);
+    if (!frontmatter) {
+        return undefined;
+    }
+    return frontmatter[field] as T | undefined;
+}
+
+/**
+ * Extracts the status from frontmatter and normalizes it.
+ *
+ * @param content - The full file content
+ * @returns Normalized ArtifactStatus
+ */
+export function extractStatus(content: string): ArtifactStatus {
+    const frontmatter = parseFrontmatter(content);
+    if (!frontmatter) {
+        return ArtifactStatus.Unknown;
+    }
+    return normalizeStatus(frontmatter.status as string | undefined);
+}

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/parser/index.ts

@@ -0,0 +1,93 @@
+/**
+ * Memory Bank Parser Module
+ *
+ * This module provides all functionality for parsing AI-DLC memory-bank artifacts.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   scanMemoryBank,
+ *   detectProject,
+ *   MemoryBankSchema,
+ *   ArtifactStatus
+ * } from './parser';
+ *
+ * const isProject = await detectProject('/path/to/workspace');
+ * if (isProject) {
+ *   const model = await scanMemoryBank('/path/to/workspace');
+ *   console.log(`Found ${model.intents.length} intents`);
+ * }
+ * ```
+ */
+
+// Types
+export {
+    ArtifactStatus,
+    Stage,
+    Story,
+    Unit,
+    Intent,
+    Bolt,
+    Standard,
+    MemoryBankModel,
+    FrontmatterData,
+    BOLT_TYPE_STAGES,
+    STAGE_ALIASES,
+    stageMatches,
+    ActivityEvent,
+    ActivityEventType
+} from './types';
+
+// Bolt Type Parser
+export {
+    getBoltTypeStages,
+    loadBoltTypeDefinition,
+    clearBoltTypeCache,
+    BoltTypeStage,
+    BoltTypeDefinition
+} from './boltTypeParser';
+
+// Schema
+export { MemoryBankSchema } from './memoryBankSchema';
+
+// Project Detection
+export {
+    detectProject,
+    detectProjectSync,
+    getProjectInfo
+} from './projectDetection';
+
+// Frontmatter Parsing
+export {
+    parseFrontmatter,
+    normalizeStatus,
+    extractFrontmatterField,
+    extractStatus
+} from './frontmatterParser';
+
+// Artifact Parsing
+export {
+    scanMemoryBank,
+    parseIntent,
+    parseUnit,
+    parseStory,
+    parseBolt,
+    parseStandard
+} from './artifactParser';
+
+// Dependency Computation
+export {
+    computeBoltDependencies,
+    getUpNextBolts,
+    isBoltBlocked,
+    getBlockingBolts,
+    countUnblocks
+} from './dependencyComputation';
+
+// Activity Feed
+export {
+    buildActivityFeed,
+    filterActivityEvents,
+    limitActivityEvents,
+    formatRelativeTime
+} from './activityFeed';

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/parser/memoryBankSchema.ts

@@ -0,0 +1,140 @@
+/**
+ * Central class for memory-bank path definitions.
+ * Provides all paths used by the artifact parser.
+ *
+ * Design note: Currently uses hardcoded paths for Phase 1.
+ * Future: Will support dynamic loading from memory-bank.yaml.
+ */
+
+import * as path from 'path';
+
+/**
+ * MemoryBankSchema provides all path definitions for memory-bank artifacts.
+ * This is the single source of truth for path construction.
+ */
+export class MemoryBankSchema {
+    private readonly workspacePath: string;
+
+    /**
+     * Creates a new MemoryBankSchema instance.
+     * @param workspacePath - The root workspace path
+     */
+    constructor(workspacePath: string) {
+        this.workspacePath = workspacePath;
+    }
+
+    /**
+     * Gets the root memory-bank folder path.
+     * @returns Path to memory-bank/
+     */
+    getMemoryBankPath(): string {
+        return path.join(this.workspacePath, 'memory-bank');
+    }
+
+    /**
+     * Gets the intents folder path.
+     * @returns Path to memory-bank/intents/
+     */
+    getIntentsPath(): string {
+        return path.join(this.getMemoryBankPath(), 'intents');
+    }
+
+    /**
+     * Gets the bolts folder path.
+     * @returns Path to memory-bank/bolts/
+     */
+    getBoltsPath(): string {
+        return path.join(this.getMemoryBankPath(), 'bolts');
+    }
+
+    /**
+     * Gets the standards folder path.
+     * @returns Path to memory-bank/standards/
+     */
+    getStandardsPath(): string {
+        return path.join(this.getMemoryBankPath(), 'standards');
+    }
+
+    /**
+     * Gets the units folder path for a specific intent.
+     * @param intentName - The intent folder name (e.g., "001-user-auth")
+     * @returns Path to memory-bank/intents/{intent}/units/
+     */
+    getUnitsPath(intentName: string): string {
+        return path.join(this.getIntentsPath(), intentName, 'units');
+    }
+
+    /**
+     * Gets the stories folder path for a specific unit.
+     * @param intentName - The intent folder name
+     * @param unitName - The unit folder name
+     * @returns Path to memory-bank/intents/{intent}/units/{unit}/stories/
+     */
+    getStoriesPath(intentName: string, unitName: string): string {
+        return path.join(this.getUnitsPath(intentName), unitName, 'stories');
+    }
+
+    /**
+     * Gets the path to a specific bolt folder.
+     * @param boltId - The bolt ID (e.g., "bolt-artifact-parser-1")
+     * @returns Path to memory-bank/bolts/{boltId}/
+     */
+    getBoltPath(boltId: string): string {
+        return path.join(this.getBoltsPath(), boltId);
+    }
+
+    /**
+     * Gets the .irismd configuration folder path.
+     * @returns Path to .irismd/
+     */
+    getSpecsmdPath(): string {
+        return path.join(this.workspacePath, '.irismd');
+    }
+
+    /**
+     * Gets the path to an intent folder.
+     * @param intentName - The intent folder name
+     * @returns Path to memory-bank/intents/{intent}/
+     */
+    getIntentPath(intentName: string): string {
+        return path.join(this.getIntentsPath(), intentName);
+    }
+
+    /**
+     * Gets the path to a unit folder.
+     * @param intentName - The intent folder name
+     * @param unitName - The unit folder name
+     * @returns Path to memory-bank/intents/{intent}/units/{unit}/
+     */
+    getUnitPath(intentName: string, unitName: string): string {
+        return path.join(this.getUnitsPath(intentName), unitName);
+    }
+
+    /**
+     * Gets the path to the unit-brief.md file.
+     * @param intentName - The intent folder name
+     * @param unitName - The unit folder name
+     * @returns Path to unit-brief.md
+     */
+    getUnitBriefPath(intentName: string, unitName: string): string {
+        return path.join(this.getUnitPath(intentName, unitName), 'unit-brief.md');
+    }
+
+    /**
+     * Gets the path to the requirements.md file for an intent.
+     * @param intentName - The intent folder name
+     * @returns Path to requirements.md
+     */
+    getRequirementsPath(intentName: string): string {
+        return path.join(this.getIntentPath(intentName), 'requirements.md');
+    }
+
+    /**
+     * Gets the path to the bolt.md file.
+     * @param boltId - The bolt ID
+     * @returns Path to bolt.md
+     */
+    getBoltFilePath(boltId: string): string {
+        return path.join(this.getBoltPath(boltId), 'bolt.md');
+    }
+}

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/parser/projectDetection.ts

@@ -0,0 +1,132 @@
+/**
+ * Project detection utilities.
+ * Determines whether a workspace is a irismd project.
+ */
+
+import * as fs from 'fs';
+import { MemoryBankSchema } from './memoryBankSchema';
+
+/**
+ * Checks if a directory exists.
+ *
+ * @param dirPath - Path to check
+ * @returns true if directory exists, false otherwise
+ */
+function directoryExists(dirPath: string): boolean {
+    try {
+        const stats = fs.statSync(dirPath);
+        return stats.isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Detects if the given workspace is a irismd project.
+ *
+ * A workspace is considered a irismd project if it has:
+ * - A `memory-bank/` folder, OR
+ * - A `.irismd/` folder
+ *
+ * @param workspacePath - The root workspace path to check
+ * @returns true if this is a irismd project, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isProject = await detectProject('/path/to/workspace');
+ * if (isProject) {
+ *   // Show artifact tree
+ * } else {
+ *   // Show welcome/install view
+ * }
+ * ```
+ */
+export async function detectProject(workspacePath: string | undefined): Promise<boolean> {
+    if (!workspacePath) {
+        return false;
+    }
+
+    const schema = new MemoryBankSchema(workspacePath);
+
+    // Check for memory-bank folder
+    const memoryBankPath = schema.getMemoryBankPath();
+    if (directoryExists(memoryBankPath)) {
+        return true;
+    }
+
+    // Check for .irismd folder
+    const irismdPath = schema.getSpecsmdPath();
+    if (directoryExists(irismdPath)) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Synchronous version of detectProject for use in activation.
+ *
+ * @param workspacePath - The root workspace path to check
+ * @returns true if this is a irismd project, false otherwise
+ */
+export function detectProjectSync(workspacePath: string | undefined): boolean {
+    if (!workspacePath) {
+        return false;
+    }
+
+    const schema = new MemoryBankSchema(workspacePath);
+
+    // Check for memory-bank folder
+    const memoryBankPath = schema.getMemoryBankPath();
+    if (directoryExists(memoryBankPath)) {
+        return true;
+    }
+
+    // Check for .irismd folder
+    const irismdPath = schema.getSpecsmdPath();
+    if (directoryExists(irismdPath)) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Gets detailed project detection info.
+ *
+ * @param workspacePath - The root workspace path to check
+ * @returns Object with detection details
+ */
+export function getProjectInfo(workspacePath: string | undefined): {
+    isProject: boolean;
+    hasMemoryBank: boolean;
+    hasSpecsmd: boolean;
+    memoryBankPath: string | null;
+    irismdPath: string | null;
+} {
+    if (!workspacePath) {
+        return {
+            isProject: false,
+            hasMemoryBank: false,
+            hasSpecsmd: false,
+            memoryBankPath: null,
+            irismdPath: null
+        };
+    }
+
+    const schema = new MemoryBankSchema(workspacePath);
+
+    const memoryBankPath = schema.getMemoryBankPath();
+    const irismdPath = schema.getSpecsmdPath();
+
+    const hasMemoryBank = directoryExists(memoryBankPath);
+    const hasSpecsmd = directoryExists(irismdPath);
+
+    return {
+        isProject: hasMemoryBank || hasSpecsmd,
+        hasMemoryBank,
+        hasSpecsmd,
+        memoryBankPath: hasMemoryBank ? memoryBankPath : null,
+        irismdPath: hasSpecsmd ? irismdPath : null
+    };
+}