project-iris 0.0.1

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

@@ -0,0 +1,241 @@
+/**
+ * TypeScript interfaces and types for memory-bank artifact parsing.
+ * These types represent the structure of AI-DLC artifacts.
+ */
+
+/**
+ * Normalized artifact status.
+ * Handles variations in status strings from frontmatter.
+ */
+export enum ArtifactStatus {
+    Draft = 'draft',
+    InProgress = 'in-progress',
+    Complete = 'complete',
+    Blocked = 'blocked',
+    Unknown = 'unknown'
+}
+
+/**
+ * Represents a stage within a bolt.
+ */
+export interface Stage {
+    name: string;
+    order: number;
+    status: ArtifactStatus;
+    /** Timestamp when stage was completed (ISO 8601) */
+    completedAt?: Date;
+    /** Artifact produced by this stage */
+    artifact?: string;
+}
+
+/**
+ * Represents a user story within a unit.
+ */
+export interface Story {
+    /** Story number, e.g., "001" */
+    id: string;
+    /** Story title from filename or frontmatter */
+    title: string;
+    /** Parent unit name */
+    unitName: string;
+    /** Parent intent name */
+    intentName: string;
+    /** Full path to story file */
+    path: string;
+    /** Parsed status */
+    status: ArtifactStatus;
+    /** Priority: must, should, could */
+    priority: string;
+}
+
+/**
+ * Represents a unit (deployable work unit) within an intent.
+ */
+export interface Unit {
+    /** Unit name from folder */
+    name: string;
+    /** Parent intent name */
+    intentName: string;
+    /** Full path to unit folder */
+    path: string;
+    /** Calculated status based on stories */
+    status: ArtifactStatus;
+    /** Raw status string from frontmatter (for display/filtering) */
+    rawStatus?: string;
+    /** Child stories */
+    stories: Story[];
+}
+
+/**
+ * Represents an intent (feature/capability).
+ */
+export interface Intent {
+    /** Intent name from folder (without number prefix) */
+    name: string;
+    /** Number prefix, e.g., "001" */
+    number: string;
+    /** Full path to intent folder */
+    path: string;
+    /** Parsed status from requirements.md or calculated */
+    status: ArtifactStatus;
+    /** Child units */
+    units: Unit[];
+}
+
+/**
+ * Represents a bolt (construction session).
+ */
+export interface Bolt {
+    /** Bolt ID, e.g., "bolt-artifact-parser-1" */
+    id: string;
+    /** Unit this bolt belongs to */
+    unit: string;
+    /** Intent this bolt belongs to */
+    intent: string;
+    /** Bolt type: simple-construction-bolt, ddd-construction-bolt */
+    type: string;
+    /** Current bolt status */
+    status: ArtifactStatus;
+    /** Current stage name, null if not started */
+    currentStage: string | null;
+    /** All stages for this bolt type */
+    stages: Stage[];
+    /** Names of completed stages */
+    stagesCompleted: string[];
+    /** Story IDs included in this bolt */
+    stories: string[];
+    /** Full path to bolt folder */
+    path: string;
+    /** Full path to bolt.md file */
+    filePath: string;
+
+    // Dependency fields
+    /** IDs of bolts that must complete before this bolt can start */
+    requiresBolts: string[];
+    /** IDs of bolts that this bolt enables (become unblocked when this completes) */
+    enablesBolts: string[];
+    /** Computed: true if any required bolts are incomplete */
+    isBlocked: boolean;
+    /** Computed: IDs of incomplete required bolts */
+    blockedBy: string[];
+    /** Computed: number of bolts this bolt enables */
+    unblocksCount: number;
+
+    // Timestamp fields for activity feed
+    /** When bolt was created (ISO 8601) */
+    createdAt?: Date;
+    /** When bolt was started (ISO 8601) */
+    startedAt?: Date;
+    /** When bolt was completed (ISO 8601) */
+    completedAt?: Date;
+}
+
+/**
+ * Represents a project standard.
+ */
+export interface Standard {
+    /** Standard name from filename */
+    name: string;
+    /** Full path to standard file */
+    path: string;
+}
+
+/**
+ * Complete model of memory-bank contents.
+ */
+export interface MemoryBankModel {
+    /** All intents with nested units and stories */
+    intents: Intent[];
+    /** All bolts */
+    bolts: Bolt[];
+    /** All standards */
+    standards: Standard[];
+    /** Whether this is a valid irismd project */
+    isProject: boolean;
+}
+
+/**
+ * Parsed frontmatter data.
+ * Keys are dynamic based on artifact type.
+ */
+export type FrontmatterData = Record<string, unknown>;
+
+/**
+ * Bolt type definitions for stage mapping.
+ */
+export const BOLT_TYPE_STAGES: Record<string, string[]> = {
+    'simple-construction-bolt': ['plan', 'implement', 'test'],
+    'ddd-construction-bolt': ['model', 'design', 'adr', 'implement', 'test'],
+    'spike-bolt': ['explore', 'document']
+};
+
+/**
+ * Stage name aliases for flexible matching.
+ * Maps canonical stage names to variations that may appear in bolt frontmatter.
+ */
+export const STAGE_ALIASES: Record<string, string[]> = {
+    'model': ['model', 'domain-model', 'domain_model'],
+    'design': ['design', 'technical-design', 'technical_design'],
+    'adr': ['adr', 'adr-analysis', 'adr_analysis'],
+    'implement': ['implement', 'implementation'],
+    'test': ['test', 'testing'],
+    'plan': ['plan', 'planning'],
+    'explore': ['explore', 'exploration'],
+    'document': ['document', 'documentation']
+};
+
+/**
+ * Check if a completed stage matches an expected stage name.
+ * Uses alias matching for flexibility.
+ */
+export function stageMatches(expectedStage: string, completedStage: string): boolean {
+    const normalizedCompleted = completedStage.toLowerCase();
+    const normalizedExpected = expectedStage.toLowerCase();
+
+    // Direct match
+    if (normalizedCompleted === normalizedExpected) {
+        return true;
+    }
+
+    // Check aliases
+    const aliases = STAGE_ALIASES[normalizedExpected];
+    if (aliases && aliases.includes(normalizedCompleted)) {
+        return true;
+    }
+
+    // Fallback: substring matching (e.g., "model" in "domain-model")
+    return normalizedCompleted.includes(normalizedExpected) ||
+           normalizedExpected.includes(normalizedCompleted);
+}
+
+/**
+ * Activity event types for the activity feed.
+ */
+export type ActivityEventType = 'bolt-created' | 'bolt-start' | 'stage-complete' | 'bolt-complete';
+
+/**
+ * Represents an activity event derived from bolt timestamps.
+ * Used to build the activity feed in the command center UI.
+ */
+export interface ActivityEvent {
+    /** Unique event ID, e.g., "bolt-artifact-parser-1-started" */
+    id: string;
+    /** Event type */
+    type: ActivityEventType;
+    /** When the event occurred */
+    timestamp: Date;
+    /** Icon character for display */
+    icon: string;
+    /** CSS class for icon styling */
+    iconClass: string;
+    /** Human-readable description */
+    text: string;
+    /** ID of the bolt this event relates to */
+    targetId: string;
+    /** Display name of the bolt */
+    targetName: string;
+    /** Category tag for filtering */
+    tag: 'bolt' | 'stage';
+    /** Path to the bolt.md file for navigation */
+    path?: string;
+}

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/sidebar/iconHelper.ts

@@ -0,0 +1,82 @@
+/**
+ * Icon helper for status-based icons with colors.
+ * Provides themed icons for VS Code TreeView.
+ */
+
+import * as vscode from 'vscode';
+import { ArtifactStatus } from '../parser/types';
+import { TreeNode, NODE_ICONS } from './types';
+
+/**
+ * Status icon configurations.
+ * Maps status to icon ID and color.
+ * Uses consistent circle icons with color indicating status.
+ */
+const STATUS_ICON_CONFIG: Record<ArtifactStatus, { icon: string; color: string }> = {
+    [ArtifactStatus.Complete]: {
+        icon: 'circle-filled',
+        color: 'charts.green'
+    },
+    [ArtifactStatus.InProgress]: {
+        icon: 'circle-filled',
+        color: 'charts.yellow'
+    },
+    [ArtifactStatus.Draft]: {
+        icon: 'circle-outline',
+        color: 'disabledForeground'
+    },
+    [ArtifactStatus.Blocked]: {
+        icon: 'circle-filled',
+        color: 'charts.red'
+    },
+    [ArtifactStatus.Unknown]: {
+        icon: 'circle-outline',
+        color: 'disabledForeground'
+    }
+};
+
+/**
+ * Gets a themed icon for a status.
+ */
+export function getStatusIcon(status: ArtifactStatus): vscode.ThemeIcon {
+    const config = STATUS_ICON_CONFIG[status];
+    return new vscode.ThemeIcon(config.icon, new vscode.ThemeColor(config.color));
+}
+
+/**
+ * Gets the appropriate icon for a tree node.
+ * Uses status-aware icons for nodes with status, otherwise uses default icons.
+ */
+export function getNodeIcon(node: TreeNode): vscode.ThemeIcon {
+    // For nodes with status, use status-aware icons
+    switch (node.kind) {
+        case 'intent':
+        case 'unit':
+        case 'story':
+            return getStatusIcon(node.data.status);
+        case 'bolt':
+            return getStatusIcon(node.data.status);
+        case 'bolt-stage':
+        case 'bolt-story':
+            return getStatusIcon(node.status);
+        default: {
+            // Use default icon from NODE_ICONS
+            const iconId = NODE_ICONS[node.kind];
+            return new vscode.ThemeIcon(iconId);
+        }
+    }
+}
+
+/**
+ * Gets bolt type badge text for display.
+ */
+export function getBoltTypeBadge(type: string): string {
+    switch (type) {
+        case 'ddd-construction-bolt':
+            return '[DDD]';
+        case 'simple-construction-bolt':
+            return '[Simple]';
+        default:
+            return '';
+    }
+}

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

@@ -0,0 +1,85 @@
+/**
+ * Public exports for the sidebar module.
+ */
+
+export {
+    TreeNode,
+    TreeNodeKind,
+    RootIntentsNode,
+    RootBoltsNode,
+    RootStandardsNode,
+    IntentNode,
+    UnitNode,
+    StoryNode,
+    BoltNode,
+    BoltStagesGroupNode,
+    BoltStageNode,
+    BoltStoriesGroupNode,
+    BoltStoryNode,
+    StandardNode,
+    NODE_ICONS,
+    STATUS_INDICATORS,
+    CollapsibleState,
+    CollapsibleStateValue,
+    getCollapsibleState,
+    isRootNode,
+    isIntentNode,
+    isUnitNode,
+    isBoltNode
+} from './types';
+
+export {
+    createRootNodes,
+    createIntentNodes,
+    createIntentNode,
+    createUnitNodes,
+    createUnitNode,
+    createStoryNodes,
+    createStoryNode,
+    createBoltNodes,
+    createBoltNode,
+    createBoltChildNodes,
+    createBoltStageNodes,
+    createBoltStoryNodes,
+    createStandardNodes,
+    createStandardNode,
+    getChildNodes
+} from './treeBuilder';
+
+export {
+    MemoryBankTreeProvider,
+    createTreeProvider
+} from './treeProvider';
+
+export {
+    getStatusIcon,
+    getNodeIcon,
+    getBoltTypeBadge
+} from './iconHelper';
+
+// Webview Provider (new tabbed interface)
+export {
+    SpecsmdWebviewProvider,
+    createWebviewProvider
+} from './webviewProvider';
+
+export {
+    WebviewData,
+    TabId,
+    DEFAULT_TAB,
+    TAB_STATE_KEY,
+    WebviewToExtensionMessage,
+    ExtensionToWebviewMessage,
+    ActiveBoltData,
+    QueuedBoltData,
+    ActivityEventData,
+    IntentData,
+    UnitData,
+    StoryData,
+    StandardData
+} from './webviewMessaging';
+
+export {
+    getWebviewContent,
+    getNonce
+} from '../webview';

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/sidebar/treeBuilder.ts

@@ -0,0 +1,289 @@
+/**
+ * Tree building functions for converting parsed artifacts to tree nodes.
+ */
+
+import { MemoryBankModel, Intent, Unit, Story, Bolt, Standard, ArtifactStatus } from '../parser/types';
+import {
+    TreeNode,
+    RootIntentsNode,
+    RootBoltsNode,
+    RootStandardsNode,
+    IntentNode,
+    UnitNode,
+    StoryNode,
+    BoltNode,
+    BoltStagesGroupNode,
+    BoltStageNode,
+    BoltStoriesGroupNode,
+    BoltStoryNode,
+    StandardNode,
+    STATUS_INDICATORS
+} from './types';
+
+/**
+ * Creates root section nodes.
+ */
+export function createRootNodes(): TreeNode[] {
+    const intentsRoot: RootIntentsNode = {
+        kind: 'root-intents',
+        label: 'Intents',
+        id: 'root-intents'
+    };
+
+    const boltsRoot: RootBoltsNode = {
+        kind: 'root-bolts',
+        label: 'Bolts',
+        id: 'root-bolts'
+    };
+
+    const standardsRoot: RootStandardsNode = {
+        kind: 'root-standards',
+        label: 'Standards',
+        id: 'root-standards'
+    };
+
+    return [intentsRoot, boltsRoot, standardsRoot];
+}
+
+/**
+ * Formats a label with status indicator.
+ */
+function formatLabelWithStatus(label: string, status: ArtifactStatus): string {
+    const indicator = STATUS_INDICATORS[status];
+    return indicator ? `${label} ${indicator}` : label;
+}
+
+/**
+ * Creates intent nodes from model.
+ */
+export function createIntentNodes(model: MemoryBankModel): IntentNode[] {
+    return model.intents.map(intent => createIntentNode(intent));
+}
+
+/**
+ * Creates a single intent node.
+ */
+export function createIntentNode(intent: Intent): IntentNode {
+    const label = `${intent.number}-${intent.name}`;
+    return {
+        kind: 'intent',
+        label: formatLabelWithStatus(label, intent.status),
+        id: `intent-${intent.number}-${intent.name}`,
+        data: intent
+    };
+}
+
+/**
+ * Creates unit nodes from an intent.
+ */
+export function createUnitNodes(intent: Intent): UnitNode[] {
+    return intent.units.map(unit => createUnitNode(unit));
+}
+
+/**
+ * Creates a single unit node.
+ */
+export function createUnitNode(unit: Unit): UnitNode {
+    return {
+        kind: 'unit',
+        label: formatLabelWithStatus(unit.name, unit.status),
+        id: `unit-${unit.intentName}-${unit.name}`,
+        data: unit
+    };
+}
+
+/**
+ * Creates story nodes from a unit.
+ */
+export function createStoryNodes(unit: Unit): StoryNode[] {
+    return unit.stories.map(story => createStoryNode(story));
+}
+
+/**
+ * Creates a single story node.
+ */
+export function createStoryNode(story: Story): StoryNode {
+    const label = `${story.id}-${story.title}`;
+    return {
+        kind: 'story',
+        label: formatLabelWithStatus(label, story.status),
+        id: `story-${story.intentName}-${story.unitName}-${story.id}`,
+        data: story
+    };
+}
+
+/**
+ * Creates bolt nodes from model.
+ */
+export function createBoltNodes(model: MemoryBankModel): BoltNode[] {
+    return model.bolts.map(bolt => createBoltNode(bolt));
+}
+
+/**
+ * Creates a single bolt node.
+ */
+export function createBoltNode(bolt: Bolt): BoltNode {
+    let label = bolt.id;
+
+    // Add current stage info for in-progress bolts
+    if (bolt.status === ArtifactStatus.InProgress && bolt.currentStage) {
+        label = `${bolt.id} (${bolt.currentStage})`;
+    }
+
+    return {
+        kind: 'bolt',
+        label: formatLabelWithStatus(label, bolt.status),
+        id: `bolt-${bolt.id}`,
+        data: bolt
+    };
+}
+
+/**
+ * Creates standard nodes from model.
+ */
+export function createStandardNodes(model: MemoryBankModel): StandardNode[] {
+    return model.standards.map(standard => createStandardNode(standard));
+}
+
+/**
+ * Creates a single standard node.
+ */
+export function createStandardNode(standard: Standard): StandardNode {
+    return {
+        kind: 'standard',
+        label: standard.name,
+        id: `standard-${standard.name}`,
+        data: standard
+    };
+}
+
+/**
+ * Creates child nodes for a bolt (stages group and stories group).
+ */
+export function createBoltChildNodes(bolt: Bolt): TreeNode[] {
+    const children: TreeNode[] = [];
+
+    // Add stages group if bolt has stages
+    if (bolt.stages && bolt.stages.length > 0) {
+        const stagesGroup: BoltStagesGroupNode = {
+            kind: 'bolt-stages-group',
+            label: 'Stages',
+            id: `bolt-${bolt.id}-stages`,
+            boltId: bolt.id,
+            data: bolt
+        };
+        children.push(stagesGroup);
+    }
+
+    // Add stories group if bolt has stories
+    if (bolt.stories && bolt.stories.length > 0) {
+        const storiesGroup: BoltStoriesGroupNode = {
+            kind: 'bolt-stories-group',
+            label: 'Stories',
+            id: `bolt-${bolt.id}-stories`,
+            boltId: bolt.id,
+            data: bolt
+        };
+        children.push(storiesGroup);
+    }
+
+    return children;
+}
+
+/**
+ * Creates stage nodes for a bolt.
+ */
+export function createBoltStageNodes(bolt: Bolt): BoltStageNode[] {
+    if (!bolt.stages) {
+        return [];
+    }
+
+    return bolt.stages.map(stage => ({
+        kind: 'bolt-stage' as const,
+        label: formatLabelWithStatus(stage.name, stage.status),
+        id: `bolt-${bolt.id}-stage-${stage.name}`,
+        boltId: bolt.id,
+        stageName: stage.name,
+        stageOrder: stage.order,
+        status: stage.status
+    }));
+}
+
+/**
+ * Finds a story's status from the model by matching file path.
+ * Uses bolt's unit/intent to construct expected story path.
+ */
+function findStoryStatus(storyId: string, bolt: Bolt, model: MemoryBankModel): ArtifactStatus {
+    // Find the unit this bolt belongs to
+    for (const intent of model.intents) {
+        // Match by intent folder name (e.g., "001-admin-panel")
+        const intentMatch = intent.path.endsWith(bolt.intent) ||
+                           `${intent.number}-${intent.name}` === bolt.intent;
+
+        if (intentMatch) {
+            for (const unit of intent.units) {
+                if (unit.name === bolt.unit) {
+                    // Found the unit - now find the story by path ending
+                    for (const story of unit.stories) {
+                        // Match by story filename (e.g., "001-create-role.md")
+                        if (story.path.endsWith(`${storyId}.md`)) {
+                            return story.status;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return ArtifactStatus.Unknown;
+}
+
+/**
+ * Creates story nodes for a bolt.
+ */
+export function createBoltStoryNodes(bolt: Bolt, model: MemoryBankModel): BoltStoryNode[] {
+    if (!bolt.stories) {
+        return [];
+    }
+
+    return bolt.stories.map(storyId => {
+        const status = findStoryStatus(storyId, bolt, model);
+        return {
+            kind: 'bolt-story' as const,
+            label: formatLabelWithStatus(storyId, status),
+            id: `bolt-${bolt.id}-story-${storyId}`,
+            boltId: bolt.id,
+            storyId: storyId,
+            status: status
+        };
+    });
+}
+
+/**
+ * Gets children for a tree node.
+ */
+export function getChildNodes(node: TreeNode, model: MemoryBankModel): TreeNode[] {
+    switch (node.kind) {
+        case 'root-intents':
+            return createIntentNodes(model);
+        case 'root-bolts':
+            return createBoltNodes(model);
+        case 'root-standards':
+            return createStandardNodes(model);
+        case 'intent':
+            return createUnitNodes(node.data);
+        case 'unit':
+            return createStoryNodes(node.data);
+        case 'bolt':
+            return createBoltChildNodes(node.data);
+        case 'bolt-stages-group':
+            return createBoltStageNodes(node.data);
+        case 'bolt-stories-group':
+            return createBoltStoryNodes(node.data, model);
+        case 'story':
+        case 'bolt-stage':
+        case 'bolt-story':
+        case 'standard':
+            return [];
+    }
+}