katashiro 0.1.1

package/src/views/knowledge-view-provider.ts

@@ -0,0 +1,204 @@
+/**
+ * KnowledgeViewProvider - Knowledge Graph panel tree view
+ *
+ * @module katashiro
+ * @task TSK-072
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * Knowledge item for tree view
+ */
+export class KnowledgeItem extends vscode.TreeItem {
+  constructor(
+    public readonly label: string,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+    public readonly itemType: 'category' | 'node' | 'edge',
+    public readonly description?: string
+  ) {
+    super(label, collapsibleState);
+    this.description = description;
+    this.contextValue = itemType;
+
+    // Set icon based on type
+    switch (itemType) {
+      case 'category':
+        this.iconPath = new vscode.ThemeIcon('folder');
+        break;
+      case 'node':
+        this.iconPath = new vscode.ThemeIcon('circle-filled');
+        break;
+      case 'edge':
+        this.iconPath = new vscode.ThemeIcon('arrow-right');
+        break;
+    }
+  }
+}
+
+/**
+ * KnowledgeViewProvider
+ *
+ * Provides tree data for the Knowledge Graph panel
+ */
+export class KnowledgeViewProvider
+  implements vscode.TreeDataProvider<KnowledgeItem>
+{
+  private _onDidChangeTreeData = new vscode.EventEmitter<
+    KnowledgeItem | undefined | null | void
+  >();
+  readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+  private nodes: Array<{ id: string; label: string; type: string }> = [];
+  private edges: Array<{ source: string; target: string; relation: string }> =
+    [];
+
+  /**
+   * Refresh the tree view
+   */
+  refresh(): void {
+    this._onDidChangeTreeData.fire();
+  }
+
+  /**
+   * Add a node
+   */
+  addNode(id: string, label: string, type: string): void {
+    this.nodes.push({ id, label, type });
+    this.refresh();
+  }
+
+  /**
+   * Add an edge
+   */
+  addEdge(source: string, target: string, relation: string): void {
+    this.edges.push({ source, target, relation });
+    this.refresh();
+  }
+
+  /**
+   * Clear all data
+   */
+  clear(): void {
+    this.nodes = [];
+    this.edges = [];
+    this.refresh();
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): { nodes: number; edges: number } {
+    return {
+      nodes: this.nodes.length,
+      edges: this.edges.length,
+    };
+  }
+
+  /**
+   * Get tree item
+   */
+  getTreeItem(element: KnowledgeItem): vscode.TreeItem {
+    return element;
+  }
+
+  /**
+   * Get children
+   */
+  getChildren(element?: KnowledgeItem): Thenable<KnowledgeItem[]> {
+    if (!element) {
+      // Root level - categories
+      const stats = this.getStats();
+      return Promise.resolve([
+        new KnowledgeItem(
+          'Nodes',
+          vscode.TreeItemCollapsibleState.Collapsed,
+          'category',
+          `${stats.nodes} items`
+        ),
+        new KnowledgeItem(
+          'Edges',
+          vscode.TreeItemCollapsibleState.Collapsed,
+          'category',
+          `${stats.edges} items`
+        ),
+        new KnowledgeItem(
+          'Actions',
+          vscode.TreeItemCollapsibleState.Collapsed,
+          'category'
+        ),
+      ]);
+    }
+
+    // Children based on category
+    switch (element.label) {
+      case 'Nodes':
+        if (this.nodes.length === 0) {
+          return Promise.resolve([
+            new KnowledgeItem(
+              'No nodes yet',
+              vscode.TreeItemCollapsibleState.None,
+              'node',
+              'Start researching to add knowledge'
+            ),
+          ]);
+        }
+        return Promise.resolve(
+          this.nodes.map(
+            (node) =>
+              new KnowledgeItem(
+                node.label,
+                vscode.TreeItemCollapsibleState.None,
+                'node',
+                node.type
+              )
+          )
+        );
+
+      case 'Edges':
+        if (this.edges.length === 0) {
+          return Promise.resolve([
+            new KnowledgeItem(
+              'No edges yet',
+              vscode.TreeItemCollapsibleState.None,
+              'edge',
+              'Connections between nodes'
+            ),
+          ]);
+        }
+        return Promise.resolve(
+          this.edges.map(
+            (edge) =>
+              new KnowledgeItem(
+                `${edge.source} → ${edge.target}`,
+                vscode.TreeItemCollapsibleState.None,
+                'edge',
+                edge.relation
+              )
+          )
+        );
+
+      case 'Actions':
+        return Promise.resolve([
+          new KnowledgeItem(
+            'View Graph',
+            vscode.TreeItemCollapsibleState.None,
+            'category'
+          ),
+          new KnowledgeItem(
+            'Export',
+            vscode.TreeItemCollapsibleState.None,
+            'category'
+          ),
+          new KnowledgeItem(
+            'Clear All',
+            vscode.TreeItemCollapsibleState.None,
+            'category'
+          ),
+        ]);
+
+      default:
+        return Promise.resolve([]);
+    }
+  }
+}

package/src/views/research-view-provider.ts

@@ -0,0 +1,141 @@
+/**
+ * ResearchViewProvider - Research panel tree view
+ *
+ * @module katashiro
+ * @task TSK-072
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * Research item for tree view
+ */
+export class ResearchItem extends vscode.TreeItem {
+  constructor(
+    public readonly label: string,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+    public readonly description?: string,
+    public readonly command?: vscode.Command
+  ) {
+    super(label, collapsibleState);
+    this.description = description;
+    this.command = command;
+  }
+}
+
+/**
+ * ResearchViewProvider
+ *
+ * Provides tree data for the Research panel
+ */
+export class ResearchViewProvider
+  implements vscode.TreeDataProvider<ResearchItem>
+{
+  private _onDidChangeTreeData = new vscode.EventEmitter<
+    ResearchItem | undefined | null | void
+  >();
+  readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+  private recentSearches: Array<{ query: string; timestamp: Date }> = [];
+
+  /**
+   * Refresh the tree view
+   */
+  refresh(): void {
+    this._onDidChangeTreeData.fire();
+  }
+
+  /**
+   * Add a recent search
+   */
+  addSearch(query: string): void {
+    this.recentSearches.unshift({ query, timestamp: new Date() });
+    if (this.recentSearches.length > 10) {
+      this.recentSearches.pop();
+    }
+    this.refresh();
+  }
+
+  /**
+   * Get tree item
+   */
+  getTreeItem(element: ResearchItem): vscode.TreeItem {
+    return element;
+  }
+
+  /**
+   * Get children
+   */
+  getChildren(element?: ResearchItem): Thenable<ResearchItem[]> {
+    if (!element) {
+      // Root level items
+      return Promise.resolve([
+        new ResearchItem(
+          'New Search',
+          vscode.TreeItemCollapsibleState.None,
+          '',
+          {
+            command: 'katashiro.webSearch',
+            title: 'New Search',
+          }
+        ),
+        new ResearchItem(
+          'Research Topic',
+          vscode.TreeItemCollapsibleState.None,
+          '',
+          {
+            command: 'katashiro.researchTopic',
+            title: 'Research Topic',
+          }
+        ),
+        new ResearchItem(
+          'Recent Searches',
+          vscode.TreeItemCollapsibleState.Expanded
+        ),
+      ]);
+    }
+
+    // Recent searches children
+    if (element.label === 'Recent Searches') {
+      if (this.recentSearches.length === 0) {
+        return Promise.resolve([
+          new ResearchItem(
+            'No recent searches',
+            vscode.TreeItemCollapsibleState.None,
+            'Start a new search'
+          ),
+        ]);
+      }
+
+      return Promise.resolve(
+        this.recentSearches.map(
+          (search) =>
+            new ResearchItem(
+              search.query,
+              vscode.TreeItemCollapsibleState.None,
+              this.formatTime(search.timestamp)
+            )
+        )
+      );
+    }
+
+    return Promise.resolve([]);
+  }
+
+  /**
+   * Format timestamp
+   */
+  private formatTime(date: Date): string {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+
+    if (diffMins < 1) return 'just now';
+    if (diffMins < 60) return `${diffMins}m ago`;
+
+    const diffHours = Math.floor(diffMins / 60);
+    if (diffHours < 24) return `${diffHours}h ago`;
+
+    return date.toLocaleDateString();
+  }
+}

package/tests/mocks/vscode.ts

@@ -0,0 +1,121 @@
+/**
+ * VS Code Mock - テスト用モック
+ *
+ * VS Code APIのモックを提供
+ */
+
+export const window = {
+  showInformationMessage: vi.fn(),
+  showWarningMessage: vi.fn(),
+  showErrorMessage: vi.fn(),
+  showInputBox: vi.fn(),
+  showQuickPick: vi.fn(),
+  withProgress: vi.fn(async (_options, task) => {
+    return task({ report: vi.fn() }, { isCancellationRequested: false });
+  }),
+  createOutputChannel: vi.fn(() => ({
+    appendLine: vi.fn(),
+    clear: vi.fn(),
+    show: vi.fn(),
+    dispose: vi.fn(),
+  })),
+  createStatusBarItem: vi.fn(() => ({
+    text: '',
+    tooltip: '',
+    command: undefined,
+    backgroundColor: undefined,
+    show: vi.fn(),
+    hide: vi.fn(),
+    dispose: vi.fn(),
+  })),
+  activeTextEditor: undefined,
+  registerTreeDataProvider: vi.fn(() => ({ dispose: vi.fn() })),
+};
+
+export const workspace = {
+  getConfiguration: vi.fn(() => ({
+    get: vi.fn((key: string, defaultValue: unknown) => defaultValue),
+  })),
+  openTextDocument: vi.fn(async (options) => ({
+    getText: vi.fn(() => options.content || ''),
+    uri: { fsPath: '/test/file.md' },
+  })),
+};
+
+export const commands = {
+  registerCommand: vi.fn(() => ({ dispose: vi.fn() })),
+  executeCommand: vi.fn(),
+};
+
+export enum TreeItemCollapsibleState {
+  None = 0,
+  Collapsed = 1,
+  Expanded = 2,
+}
+
+export class TreeItem {
+  label: string;
+  collapsibleState: TreeItemCollapsibleState;
+  description?: string;
+  tooltip?: string;
+  command?: Command;
+  iconPath?: ThemeIcon;
+  contextValue?: string;
+
+  constructor(
+    label: string,
+    collapsibleState: TreeItemCollapsibleState = TreeItemCollapsibleState.None
+  ) {
+    this.label = label;
+    this.collapsibleState = collapsibleState;
+  }
+}
+
+export interface Command {
+  command: string;
+  title: string;
+  arguments?: unknown[];
+}
+
+export class ThemeIcon {
+  constructor(public readonly id: string) {}
+}
+
+export class ThemeColor {
+  constructor(public readonly id: string) {}
+}
+
+export enum StatusBarAlignment {
+  Left = 1,
+  Right = 2,
+}
+
+export class EventEmitter<T> {
+  private listeners: Array<(e: T) => void> = [];
+
+  event = (listener: (e: T) => void) => {
+    this.listeners.push(listener);
+    return { dispose: () => {} };
+  };
+
+  fire(data: T): void {
+    this.listeners.forEach((l) => l(data));
+  }
+}
+
+export enum ProgressLocation {
+  Notification = 15,
+  Window = 10,
+  SourceControl = 1,
+}
+
+export enum ViewColumn {
+  Active = -1,
+  Beside = -2,
+  One = 1,
+  Two = 2,
+  Three = 3,
+}
+
+// Re-export vi for test files
+import { vi } from 'vitest';

package/tests/unit/history-view-provider.test.ts

@@ -0,0 +1,150 @@
+/**
+ * HistoryViewProvider テスト
+ *
+ * @task TSK-072
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Mock vscode module
+vi.mock('vscode', () => import('../mocks/vscode.js'));
+
+import {
+  HistoryViewProvider,
+  HistoryItem,
+} from '../../src/views/history-view-provider.js';
+
+describe('HistoryViewProvider', () => {
+  let provider: HistoryViewProvider;
+
+  beforeEach(() => {
+    provider = new HistoryViewProvider();
+  });
+
+  describe('initialization', () => {
+    it('should create provider', () => {
+      expect(provider).toBeDefined();
+    });
+
+    it('should have empty history initially', () => {
+      const all = provider.getAll();
+      expect(all.length).toBe(0);
+    });
+  });
+
+  describe('addEntry', () => {
+    it('should add entry', () => {
+      const entry = provider.addEntry('search', 'Test Search', 'Details');
+
+      expect(entry.id).toBeDefined();
+      expect(entry.type).toBe('search');
+      expect(entry.title).toBe('Test Search');
+      expect(entry.details).toBe('Details');
+      expect(entry.timestamp).toBeInstanceOf(Date);
+    });
+
+    it('should add multiple entries in order', () => {
+      provider.addEntry('search', 'First');
+      provider.addEntry('analysis', 'Second');
+      provider.addEntry('summary', 'Third');
+
+      const all = provider.getAll();
+      expect(all.length).toBe(3);
+      expect(all[0].title).toBe('Third'); // Most recent first
+      expect(all[2].title).toBe('First');
+    });
+
+    it('should limit to 50 entries', () => {
+      for (let i = 0; i < 60; i++) {
+        provider.addEntry('search', `Entry ${i}`);
+      }
+
+      const all = provider.getAll();
+      expect(all.length).toBe(50);
+    });
+  });
+
+  describe('getEntry', () => {
+    it('should get entry by ID', () => {
+      const added = provider.addEntry('search', 'Test');
+      const found = provider.getEntry(added.id);
+
+      expect(found).toBeDefined();
+      expect(found?.id).toBe(added.id);
+    });
+
+    it('should return undefined for unknown ID', () => {
+      const found = provider.getEntry('unknown-id');
+      expect(found).toBeUndefined();
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all entries', () => {
+      provider.addEntry('search', 'Test 1');
+      provider.addEntry('analysis', 'Test 2');
+
+      provider.clear();
+
+      const all = provider.getAll();
+      expect(all.length).toBe(0);
+    });
+  });
+
+  describe('getChildren', () => {
+    it('should return empty array when no history', async () => {
+      const children = await provider.getChildren();
+      expect(children.length).toBe(0);
+    });
+
+    it('should return history items', async () => {
+      provider.addEntry('search', 'Search 1');
+      provider.addEntry('analysis', 'Analysis 1');
+
+      const children = await provider.getChildren();
+      expect(children.length).toBe(2);
+    });
+
+    it('should return no children for items', async () => {
+      provider.addEntry('search', 'Test');
+      const children = await provider.getChildren();
+      const itemChildren = await provider.getChildren(children[0]);
+
+      expect(itemChildren.length).toBe(0);
+    });
+  });
+});
+
+describe('HistoryItem', () => {
+  it('should create item from entry', () => {
+    const entry = {
+      id: 'test-id',
+      type: 'search' as const,
+      title: 'Test Search',
+      timestamp: new Date(),
+      details: 'Test details',
+    };
+
+    const item = new HistoryItem(entry, 0);
+
+    expect(item.entry).toBe(entry);
+    expect(item.label).toBe('Test Search');
+    expect(item.contextValue).toBe('search');
+  });
+
+  it('should set icon based on type', () => {
+    const types = ['search', 'analysis', 'summary', 'research', 'report'] as const;
+
+    for (const type of types) {
+      const entry = {
+        id: `${type}-id`,
+        type,
+        title: `Test ${type}`,
+        timestamp: new Date(),
+      };
+
+      const item = new HistoryItem(entry, 0);
+      expect(item.iconPath).toBeDefined();
+    }
+  });
+});