project-iris 0.0.1

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

@@ -0,0 +1,225 @@
+/**
+ * TreeDataProvider implementation for the memory-bank sidebar.
+ */
+
+import * as vscode from 'vscode';
+import { MemoryBankModel } from '../parser/types';
+import { scanMemoryBank } from '../parser/artifactParser';
+import {
+    TreeNode,
+    getCollapsibleState
+} from './types';
+import {
+    createRootNodes,
+    getChildNodes
+} from './treeBuilder';
+import { getNodeIcon, getBoltTypeBadge } from './iconHelper';
+
+/**
+ * TreeDataProvider for the memory-bank view.
+ * Displays Intents, Bolts, and Standards in a hierarchical tree.
+ */
+export class MemoryBankTreeProvider implements vscode.TreeDataProvider<TreeNode> {
+    private model: MemoryBankModel | null = null;
+    private workspacePath: string | undefined;
+
+    /**
+     * Event emitter for tree data changes.
+     * Fire this to refresh the tree view.
+     */
+    private _onDidChangeTreeData = new vscode.EventEmitter<TreeNode | undefined | null | void>();
+    readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+    /**
+     * Creates a new MemoryBankTreeProvider.
+     * @param workspacePath Optional workspace path. If not provided, uses first workspace folder.
+     */
+    constructor(workspacePath?: string) {
+        this.workspacePath = workspacePath;
+    }
+
+    /**
+     * Gets the workspace path, falling back to first workspace folder.
+     */
+    private getWorkspacePath(): string | undefined {
+        if (this.workspacePath) {
+            return this.workspacePath;
+        }
+        const folders = vscode.workspace.workspaceFolders;
+        return folders && folders.length > 0 ? folders[0].uri.fsPath : undefined;
+    }
+
+    /**
+     * Refreshes the tree by rescanning the memory-bank.
+     */
+    async refresh(): Promise<void> {
+        const workspacePath = this.getWorkspacePath();
+        if (workspacePath) {
+            this.model = await scanMemoryBank(workspacePath);
+        } else {
+            this.model = null;
+        }
+        this._onDidChangeTreeData.fire();
+    }
+
+    /**
+     * Gets the current model (for testing).
+     */
+    getModel(): MemoryBankModel | null {
+        return this.model;
+    }
+
+    /**
+     * Sets the model directly (for testing).
+     */
+    setModel(model: MemoryBankModel): void {
+        this.model = model;
+    }
+
+    /**
+     * Converts a TreeNode to a TreeItem for display.
+     */
+    getTreeItem(element: TreeNode): vscode.TreeItem {
+        // Add bolt type badge to bolt labels
+        let label = element.label;
+        if (element.kind === 'bolt') {
+            const badge = getBoltTypeBadge(element.data.type);
+            if (badge) {
+                // Insert badge before status indicator
+                const parts = label.split(' ');
+                if (parts.length > 1 && /[\u2713\u25CF\u25CB]/.test(parts[parts.length - 1])) {
+                    parts.splice(parts.length - 1, 0, badge);
+                    label = parts.join(' ');
+                } else {
+                    label = `${label} ${badge}`;
+                }
+            }
+        }
+
+        const item = new vscode.TreeItem(
+            label,
+            getCollapsibleState(element)
+        );
+
+        // Set status-aware icon
+        item.iconPath = getNodeIcon(element);
+
+        // Set unique ID for element tracking
+        item.id = element.id;
+
+        // Set tooltip
+        item.tooltip = this.getTooltip(element);
+
+        // Set context value for menu contributions
+        item.contextValue = element.kind;
+
+        // Set command for leaf nodes
+        if (this.isClickableNode(element)) {
+            item.command = {
+                command: 'irismd.openArtifact',
+                title: 'Open Artifact',
+                arguments: [element]
+            };
+        }
+
+        return item;
+    }
+
+    /**
+     * Checks if a node should be clickable.
+     */
+    private isClickableNode(node: TreeNode): boolean {
+        return node.kind === 'story' ||
+               node.kind === 'bolt' ||
+               node.kind === 'standard';
+    }
+
+    /**
+     * Gets tooltip text for a node.
+     */
+    private getTooltip(node: TreeNode): string {
+        switch (node.kind) {
+            case 'root-intents':
+                return 'Features and capabilities';
+            case 'root-bolts':
+                return 'Construction sessions';
+            case 'root-standards':
+                return 'Project standards';
+            case 'intent':
+                return `Intent: ${node.data.number}-${node.data.name}\nUnits: ${node.data.units.length}`;
+            case 'unit':
+                return `Unit: ${node.data.name}\nStories: ${node.data.stories.length}`;
+            case 'story':
+                return `Story: ${node.data.id}-${node.data.title}\nPriority: ${node.data.priority}`;
+            case 'bolt':
+                return `Bolt: ${node.data.id}\nType: ${node.data.type}\nStatus: ${node.data.status}\nStages: ${node.data.stages.length}`;
+            case 'bolt-stages-group':
+                return `Stages for ${node.boltId}`;
+            case 'bolt-stage':
+                return `Stage ${node.stageOrder}: ${node.stageName}\nStatus: ${node.status}`;
+            case 'bolt-stories-group':
+                return `Stories included in ${node.boltId}`;
+            case 'bolt-story':
+                return `Story: ${node.storyId}`;
+            case 'standard':
+                return `Standard: ${node.data.name}`;
+        }
+    }
+
+    /**
+     * Gets children for a tree element.
+     * Returns root nodes if no element is provided.
+     */
+    getChildren(element?: TreeNode): vscode.ProviderResult<TreeNode[]> {
+        // Return empty if no model loaded
+        if (!this.model || !this.model.isProject) {
+            return [];
+        }
+
+        // Root level - return section nodes
+        if (!element) {
+            return createRootNodes();
+        }
+
+        // Return children based on node type
+        return getChildNodes(element, this.model);
+    }
+
+    /**
+     * Gets parent of a tree element (for reveal functionality).
+     */
+    getParent(_element: TreeNode): vscode.ProviderResult<TreeNode> {
+        // Parent lookup would require storing parent references
+        // For now, return undefined (tree will still function)
+        return undefined;
+    }
+
+    /**
+     * Disposes resources.
+     */
+    dispose(): void {
+        this._onDidChangeTreeData.dispose();
+    }
+}
+
+/**
+ * Creates and registers a MemoryBankTreeProvider.
+ */
+export function createTreeProvider(
+    context: vscode.ExtensionContext,
+    workspacePath?: string
+): MemoryBankTreeProvider {
+    const provider = new MemoryBankTreeProvider(workspacePath);
+
+    // Register the tree data provider
+    const treeView = vscode.window.createTreeView('irismdExplorer', {
+        treeDataProvider: provider,
+        showCollapseAll: true
+    });
+
+    // Add to subscriptions for cleanup
+    context.subscriptions.push(treeView);
+    context.subscriptions.push(provider);
+
+    return provider;
+}

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

@@ -0,0 +1,254 @@
+/**
+ * Type definitions for the memory-bank tree view.
+ * Uses discriminated unions for type-safe tree node handling.
+ *
+ * Note: This file intentionally does NOT import vscode to allow unit testing
+ * without the VS Code runtime. VS Code-specific functions are in treeProvider.ts.
+ */
+
+import { Intent, Unit, Story, Bolt, Standard, ArtifactStatus } from '../parser/types';
+
+/**
+ * Node kinds for the tree view.
+ */
+export type TreeNodeKind =
+    | 'root-intents'
+    | 'root-bolts'
+    | 'root-standards'
+    | 'intent'
+    | 'unit'
+    | 'story'
+    | 'bolt'
+    | 'bolt-stages-group'
+    | 'bolt-stage'
+    | 'bolt-stories-group'
+    | 'bolt-story'
+    | 'standard';
+
+/**
+ * Base interface for all tree nodes.
+ */
+interface BaseTreeNode {
+    kind: TreeNodeKind;
+    label: string;
+    id: string;
+}
+
+/**
+ * Root section nodes.
+ */
+export interface RootIntentsNode extends BaseTreeNode {
+    kind: 'root-intents';
+}
+
+export interface RootBoltsNode extends BaseTreeNode {
+    kind: 'root-bolts';
+}
+
+export interface RootStandardsNode extends BaseTreeNode {
+    kind: 'root-standards';
+}
+
+/**
+ * Intent node with nested data.
+ */
+export interface IntentNode extends BaseTreeNode {
+    kind: 'intent';
+    data: Intent;
+}
+
+/**
+ * Unit node with nested data.
+ */
+export interface UnitNode extends BaseTreeNode {
+    kind: 'unit';
+    data: Unit;
+}
+
+/**
+ * Story node with nested data.
+ */
+export interface StoryNode extends BaseTreeNode {
+    kind: 'story';
+    data: Story;
+}
+
+/**
+ * Bolt node with nested data.
+ */
+export interface BoltNode extends BaseTreeNode {
+    kind: 'bolt';
+    data: Bolt;
+}
+
+/**
+ * Group node for bolt stages.
+ */
+export interface BoltStagesGroupNode extends BaseTreeNode {
+    kind: 'bolt-stages-group';
+    boltId: string;
+    data: Bolt;
+}
+
+/**
+ * Individual bolt stage node.
+ */
+export interface BoltStageNode extends BaseTreeNode {
+    kind: 'bolt-stage';
+    boltId: string;
+    stageName: string;
+    stageOrder: number;
+    status: ArtifactStatus;
+}
+
+/**
+ * Group node for bolt stories.
+ */
+export interface BoltStoriesGroupNode extends BaseTreeNode {
+    kind: 'bolt-stories-group';
+    boltId: string;
+    data: Bolt;
+}
+
+/**
+ * Individual bolt story node.
+ */
+export interface BoltStoryNode extends BaseTreeNode {
+    kind: 'bolt-story';
+    boltId: string;
+    storyId: string;
+    status: ArtifactStatus;
+}
+
+/**
+ * Standard node with nested data.
+ */
+export interface StandardNode extends BaseTreeNode {
+    kind: 'standard';
+    data: Standard;
+}
+
+/**
+ * Union type for all tree nodes.
+ */
+export type TreeNode =
+    | RootIntentsNode
+    | RootBoltsNode
+    | RootStandardsNode
+    | IntentNode
+    | UnitNode
+    | StoryNode
+    | BoltNode
+    | BoltStagesGroupNode
+    | BoltStageNode
+    | BoltStoriesGroupNode
+    | BoltStoryNode
+    | StandardNode;
+
+/**
+ * Icon configuration for tree nodes.
+ */
+export const NODE_ICONS: Record<TreeNodeKind, string> = {
+    'root-intents': 'folder-library',
+    'root-bolts': 'tools',
+    'root-standards': 'law',
+    'intent': 'package',
+    'unit': 'symbol-module',
+    'story': 'note',
+    'bolt': 'wrench',
+    'bolt-stages-group': 'list-tree',
+    'bolt-stage': 'circle-outline',
+    'bolt-stories-group': 'list-unordered',
+    'bolt-story': 'note',
+    'standard': 'file-text'
+};
+
+/**
+ * Status indicators for display.
+ */
+export const STATUS_INDICATORS: Record<ArtifactStatus, string> = {
+    [ArtifactStatus.Complete]: '\u2713',  // checkmark
+    [ArtifactStatus.InProgress]: '\u25CF', // filled circle
+    [ArtifactStatus.Draft]: '\u25CB',      // empty circle
+    [ArtifactStatus.Blocked]: '\u2717',    // X mark for blocked
+    [ArtifactStatus.Unknown]: ''
+};
+
+/**
+ * Collapsible state values (matching vscode.TreeItemCollapsibleState).
+ * Defined here to avoid vscode import in this file.
+ */
+export const CollapsibleState = {
+    None: 0,
+    Collapsed: 1,
+    Expanded: 2
+} as const;
+
+export type CollapsibleStateValue = typeof CollapsibleState[keyof typeof CollapsibleState];
+
+/**
+ * Gets the collapsible state for a tree node.
+ * Returns values matching vscode.TreeItemCollapsibleState.
+ */
+export function getCollapsibleState(node: TreeNode): CollapsibleStateValue {
+    switch (node.kind) {
+        case 'root-intents':
+        case 'root-bolts':
+        case 'root-standards':
+            return CollapsibleState.Expanded;
+        case 'intent':
+            return node.data.units.length > 0
+                ? CollapsibleState.Collapsed
+                : CollapsibleState.None;
+        case 'unit':
+            return node.data.stories.length > 0
+                ? CollapsibleState.Collapsed
+                : CollapsibleState.None;
+        case 'bolt':
+            // Bolts are expandable to show stages and stories
+            return CollapsibleState.Collapsed;
+        case 'bolt-stages-group':
+            return node.data.stages.length > 0
+                ? CollapsibleState.Collapsed
+                : CollapsibleState.None;
+        case 'bolt-stories-group':
+            return node.data.stories.length > 0
+                ? CollapsibleState.Collapsed
+                : CollapsibleState.None;
+        case 'story':
+        case 'bolt-stage':
+        case 'bolt-story':
+        case 'standard':
+            return CollapsibleState.None;
+    }
+}
+
+/**
+ * Type guard for root nodes.
+ */
+export function isRootNode(node: TreeNode): node is RootIntentsNode | RootBoltsNode | RootStandardsNode {
+    return node.kind === 'root-intents' ||
+           node.kind === 'root-bolts' ||
+           node.kind === 'root-standards';
+}
+
+/**
+ * Type guard for intent nodes.
+ */
+export function isIntentNode(node: TreeNode): node is IntentNode {
+    return node.kind === 'intent';
+}
+
+/**
+ * Type guard for unit nodes.
+ */
+export function isUnitNode(node: TreeNode): node is UnitNode {
+    return node.kind === 'unit';
+}
+
+/**
+ * Type guard for bolt nodes.
+ */
+export function isBoltNode(node: TreeNode): node is BoltNode {
+    return node.kind === 'bolt';
+}