katashiro 0.1.1

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

@@ -0,0 +1,120 @@
+/**
+ * KnowledgeViewProvider テスト
+ *
+ * @task TSK-072
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Mock vscode module
+vi.mock('vscode', () => import('../mocks/vscode.js'));
+
+import {
+  KnowledgeViewProvider,
+  KnowledgeItem,
+} from '../../src/views/knowledge-view-provider.js';
+
+describe('KnowledgeViewProvider', () => {
+  let provider: KnowledgeViewProvider;
+
+  beforeEach(() => {
+    provider = new KnowledgeViewProvider();
+  });
+
+  describe('initialization', () => {
+    it('should create provider', () => {
+      expect(provider).toBeDefined();
+    });
+
+    it('should have empty stats initially', () => {
+      const stats = provider.getStats();
+      expect(stats.nodes).toBe(0);
+      expect(stats.edges).toBe(0);
+    });
+  });
+
+  describe('getChildren', () => {
+    it('should return root categories', async () => {
+      const children = await provider.getChildren();
+      expect(children.length).toBe(3);
+
+      const labels = children.map((c) => c.label);
+      expect(labels).toContain('Nodes');
+      expect(labels).toContain('Edges');
+      expect(labels).toContain('Actions');
+    });
+
+    it('should return empty nodes message initially', async () => {
+      const root = await provider.getChildren();
+      const nodes = root.find((r) => r.label === 'Nodes');
+      const children = await provider.getChildren(nodes);
+
+      expect(children.length).toBe(1);
+      expect(children[0].label).toBe('No nodes yet');
+    });
+  });
+
+  describe('addNode', () => {
+    it('should add node', async () => {
+      provider.addNode('node-1', 'Test Node', 'entity');
+
+      const stats = provider.getStats();
+      expect(stats.nodes).toBe(1);
+
+      const root = await provider.getChildren();
+      const nodes = root.find((r) => r.label === 'Nodes');
+      const children = await provider.getChildren(nodes);
+
+      expect(children.length).toBe(1);
+      expect(children[0].label).toBe('Test Node');
+    });
+  });
+
+  describe('addEdge', () => {
+    it('should add edge', async () => {
+      provider.addEdge('node-1', 'node-2', 'relates_to');
+
+      const stats = provider.getStats();
+      expect(stats.edges).toBe(1);
+
+      const root = await provider.getChildren();
+      const edges = root.find((r) => r.label === 'Edges');
+      const children = await provider.getChildren(edges);
+
+      expect(children.length).toBe(1);
+      expect(children[0].label).toBe('node-1 → node-2');
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all data', async () => {
+      provider.addNode('node-1', 'Node 1', 'entity');
+      provider.addEdge('node-1', 'node-2', 'relates_to');
+
+      provider.clear();
+
+      const stats = provider.getStats();
+      expect(stats.nodes).toBe(0);
+      expect(stats.edges).toBe(0);
+    });
+  });
+});
+
+describe('KnowledgeItem', () => {
+  it('should create item with type', () => {
+    const item = new KnowledgeItem('Test', 0, 'node');
+    expect(item.label).toBe('Test');
+    expect(item.itemType).toBe('node');
+    expect(item.contextValue).toBe('node');
+  });
+
+  it('should set icon based on type', () => {
+    const nodeItem = new KnowledgeItem('Node', 0, 'node');
+    const edgeItem = new KnowledgeItem('Edge', 0, 'edge');
+    const categoryItem = new KnowledgeItem('Category', 0, 'category');
+
+    expect(nodeItem.iconPath).toBeDefined();
+    expect(edgeItem.iconPath).toBeDefined();
+    expect(categoryItem.iconPath).toBeDefined();
+  });
+});

package/tests/unit/output-channel-manager.test.ts

@@ -0,0 +1,75 @@
+/**
+ * OutputChannelManager テスト
+ *
+ * @task TSK-073
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Mock vscode module
+vi.mock('vscode', () => import('../mocks/vscode.js'));
+
+import { OutputChannelManager } from '../../src/ui/output-channel-manager.js';
+
+describe('OutputChannelManager', () => {
+  let manager: OutputChannelManager;
+
+  beforeEach(() => {
+    manager = new OutputChannelManager('Test');
+  });
+
+  describe('initialization', () => {
+    it('should create manager', () => {
+      expect(manager).toBeDefined();
+    });
+  });
+
+  describe('log', () => {
+    it('should log info message', () => {
+      expect(() => manager.log('Test message')).not.toThrow();
+    });
+
+    it('should log with different levels', () => {
+      expect(() => manager.log('Info', 'info')).not.toThrow();
+      expect(() => manager.log('Warn', 'warn')).not.toThrow();
+      expect(() => manager.log('Error', 'error')).not.toThrow();
+      expect(() => manager.log('Debug', 'debug')).not.toThrow();
+    });
+  });
+
+  describe('convenience methods', () => {
+    it('should have info method', () => {
+      expect(() => manager.info('Info message')).not.toThrow();
+    });
+
+    it('should have warn method', () => {
+      expect(() => manager.warn('Warning message')).not.toThrow();
+    });
+
+    it('should have error method', () => {
+      expect(() => manager.error('Error message')).not.toThrow();
+    });
+
+    it('should have debug method', () => {
+      expect(() => manager.debug('Debug message')).not.toThrow();
+    });
+  });
+
+  describe('show', () => {
+    it('should show channel', () => {
+      expect(() => manager.show()).not.toThrow();
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear channel', () => {
+      expect(() => manager.clear()).not.toThrow();
+    });
+  });
+
+  describe('dispose', () => {
+    it('should dispose channel', () => {
+      expect(() => manager.dispose()).not.toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,111 @@
+/**
+ * ResearchViewProvider テスト
+ *
+ * @task TSK-072
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Mock vscode module
+vi.mock('vscode', () => import('../mocks/vscode.js'));
+
+import {
+  ResearchViewProvider,
+  ResearchItem,
+} from '../../src/views/research-view-provider.js';
+
+describe('ResearchViewProvider', () => {
+  let provider: ResearchViewProvider;
+
+  beforeEach(() => {
+    provider = new ResearchViewProvider();
+  });
+
+  describe('initialization', () => {
+    it('should create provider', () => {
+      expect(provider).toBeDefined();
+    });
+
+    it('should have onDidChangeTreeData event', () => {
+      expect(provider.onDidChangeTreeData).toBeDefined();
+    });
+  });
+
+  describe('getChildren', () => {
+    it('should return root items', async () => {
+      const children = await provider.getChildren();
+      expect(children.length).toBe(3);
+
+      const labels = children.map((c) => c.label);
+      expect(labels).toContain('New Search');
+      expect(labels).toContain('Research Topic');
+      expect(labels).toContain('Recent Searches');
+    });
+
+    it('should return empty recent searches initially', async () => {
+      const root = await provider.getChildren();
+      const recentSearches = root.find((r) => r.label === 'Recent Searches');
+
+      expect(recentSearches).toBeDefined();
+
+      const children = await provider.getChildren(recentSearches);
+      expect(children.length).toBe(1);
+      expect(children[0].label).toBe('No recent searches');
+    });
+  });
+
+  describe('addSearch', () => {
+    it('should add search to recent searches', async () => {
+      provider.addSearch('test query');
+
+      const root = await provider.getChildren();
+      const recentSearches = root.find((r) => r.label === 'Recent Searches');
+      const children = await provider.getChildren(recentSearches);
+
+      expect(children.length).toBe(1);
+      expect(children[0].label).toBe('test query');
+    });
+
+    it('should limit to 10 recent searches', async () => {
+      for (let i = 0; i < 15; i++) {
+        provider.addSearch(`query ${i}`);
+      }
+
+      const root = await provider.getChildren();
+      const recentSearches = root.find((r) => r.label === 'Recent Searches');
+      const children = await provider.getChildren(recentSearches);
+
+      expect(children.length).toBe(10);
+      expect(children[0].label).toBe('query 14'); // Most recent
+    });
+  });
+
+  describe('getTreeItem', () => {
+    it('should return the item itself', async () => {
+      const item = new ResearchItem(
+        'Test',
+        0 // TreeItemCollapsibleState.None
+      );
+      const result = provider.getTreeItem(item);
+      expect(result).toBe(item);
+    });
+  });
+});
+
+describe('ResearchItem', () => {
+  it('should create item with label', () => {
+    const item = new ResearchItem('Test Label', 0);
+    expect(item.label).toBe('Test Label');
+  });
+
+  it('should create item with description', () => {
+    const item = new ResearchItem('Test', 0, 'Description');
+    expect(item.description).toBe('Description');
+  });
+
+  it('should create item with command', () => {
+    const command = { command: 'test.command', title: 'Test' };
+    const item = new ResearchItem('Test', 0, '', command);
+    expect(item.command).toBe(command);
+  });
+});

package/tests/unit/status-bar-manager.test.ts

@@ -0,0 +1,101 @@
+/**
+ * StatusBarManager テスト
+ *
+ * @task TSK-073
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Mock vscode module
+vi.mock('vscode', () => import('../mocks/vscode.js'));
+
+import { StatusBarManager } from '../../src/ui/status-bar-manager.js';
+
+describe('StatusBarManager', () => {
+  let manager: StatusBarManager;
+
+  beforeEach(() => {
+    manager = new StatusBarManager();
+  });
+
+  describe('initialization', () => {
+    it('should create manager', () => {
+      expect(manager).toBeDefined();
+    });
+
+    it('should start in idle state', () => {
+      expect(manager.getState()).toBe('idle');
+    });
+  });
+
+  describe('show/hide', () => {
+    it('should show status bar', () => {
+      expect(() => manager.show()).not.toThrow();
+    });
+
+    it('should hide status bar', () => {
+      expect(() => manager.hide()).not.toThrow();
+    });
+  });
+
+  describe('setIdle', () => {
+    it('should set idle state', () => {
+      manager.setWorking();
+      manager.setIdle();
+      expect(manager.getState()).toBe('idle');
+    });
+
+    it('should set idle with custom message', () => {
+      manager.setIdle('Custom message');
+      expect(manager.getState()).toBe('idle');
+    });
+  });
+
+  describe('setWorking', () => {
+    it('should set working state', () => {
+      manager.setWorking();
+      expect(manager.getState()).toBe('working');
+    });
+
+    it('should set working with message', () => {
+      manager.setWorking('Processing...');
+      expect(manager.getState()).toBe('working');
+    });
+  });
+
+  describe('setSuccess', () => {
+    it('should set success state', () => {
+      manager.setSuccess('Complete', 0);
+      expect(manager.getState()).toBe('success');
+    });
+
+    it('should auto-reset to idle', async () => {
+      manager.setSuccess('Done', 100);
+      expect(manager.getState()).toBe('success');
+
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      expect(manager.getState()).toBe('idle');
+    });
+  });
+
+  describe('setError', () => {
+    it('should set error state', () => {
+      manager.setError('Failed', 0);
+      expect(manager.getState()).toBe('error');
+    });
+
+    it('should auto-reset to idle', async () => {
+      manager.setError('Error', 100);
+      expect(manager.getState()).toBe('error');
+
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      expect(manager.getState()).toBe('idle');
+    });
+  });
+
+  describe('dispose', () => {
+    it('should dispose manager', () => {
+      expect(() => manager.dispose()).not.toThrow();
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "module": "CommonJS",
+    "moduleResolution": "Node"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"],
+  "references": [
+    { "path": "../core" },
+    { "path": "../collector" },
+    { "path": "../analyzer" },
+    { "path": "../generator" },
+    { "path": "../knowledge" },
+    { "path": "../feedback" },
+    { "path": "../mcp-server" }
+  ]
+}