katashiro 0.1.1

package/src/index.ts

@@ -0,0 +1,36 @@
+/**
+ * @nahisaho/katashiro-vscode-extension
+ * VS Code拡張機能
+ *
+ * @requirement REQ-VSCODE-001 ~ REQ-VSCODE-004
+ * @design DES-KATASHIRO-001 §2.3 VS Code Extension
+ */
+
+// Extension entry points
+export { activate, deactivate } from './extension.js';
+
+// Extension controller
+export { KatashiroExtension, type KatashiroConfig } from './katashiro-extension.js';
+
+// Commands
+export { CommandManager } from './commands/index.js';
+
+// Views
+export {
+  ResearchViewProvider,
+  ResearchItem,
+  KnowledgeViewProvider,
+  KnowledgeItem,
+  HistoryViewProvider,
+  HistoryItem,
+  type HistoryEntry,
+  type HistoryEntryType,
+} from './views/index.js';
+
+// UI
+export {
+  OutputChannelManager,
+  StatusBarManager,
+  type LogLevel,
+  type StatusBarState,
+} from './ui/index.js';

package/src/katashiro-extension.ts

@@ -0,0 +1,125 @@
+/**
+ * KatashiroExtension - Main extension controller
+ *
+ * Manages commands, views, and integration with KATASHIRO packages
+ *
+ * @module katashiro
+ * @task TSK-070
+ */
+
+import * as vscode from 'vscode';
+import { CommandManager } from './commands/command-manager.js';
+import { ResearchViewProvider } from './views/research-view-provider.js';
+import { KnowledgeViewProvider } from './views/knowledge-view-provider.js';
+import { HistoryViewProvider } from './views/history-view-provider.js';
+import { StatusBarManager } from './ui/status-bar-manager.js';
+import { OutputChannelManager } from './ui/output-channel-manager.js';
+
+/**
+ * Extension configuration
+ */
+export interface KatashiroConfig {
+  searchEngine: 'duckduckgo' | 'google' | 'bing';
+  maxSearchResults: number;
+  outputFormat: 'markdown' | 'html' | 'json';
+  autoSaveKnowledge: boolean;
+  mcpServerPort: number;
+}
+
+/**
+ * KatashiroExtension
+ *
+ * Main controller for the KATASHIRO VS Code extension
+ */
+export class KatashiroExtension {
+  private commandManager: CommandManager;
+  private researchViewProvider: ResearchViewProvider;
+  private knowledgeViewProvider: KnowledgeViewProvider;
+  private historyViewProvider: HistoryViewProvider;
+  private statusBarManager: StatusBarManager;
+  private outputChannelManager: OutputChannelManager;
+
+  constructor(private readonly context: vscode.ExtensionContext) {
+    // Initialize managers
+    this.outputChannelManager = new OutputChannelManager();
+    this.statusBarManager = new StatusBarManager();
+    this.commandManager = new CommandManager(
+      context,
+      this.outputChannelManager
+    );
+
+    // Initialize view providers
+    this.researchViewProvider = new ResearchViewProvider();
+    this.knowledgeViewProvider = new KnowledgeViewProvider();
+    this.historyViewProvider = new HistoryViewProvider();
+  }
+
+  /**
+   * Activate the extension
+   */
+  async activate(): Promise<void> {
+    // Register commands
+    this.commandManager.registerAll();
+
+    // Register view providers
+    this.registerViewProviders();
+
+    // Initialize status bar
+    this.statusBarManager.show();
+
+    // Log activation
+    this.outputChannelManager.log('KATASHIRO extension activated');
+  }
+
+  /**
+   * Deactivate the extension
+   */
+  async deactivate(): Promise<void> {
+    this.statusBarManager.dispose();
+    this.outputChannelManager.dispose();
+    this.outputChannelManager.log('KATASHIRO extension deactivated');
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): KatashiroConfig {
+    const config = vscode.workspace.getConfiguration('katashiro');
+    return {
+      searchEngine: config.get('searchEngine', 'duckduckgo'),
+      maxSearchResults: config.get('maxSearchResults', 10),
+      outputFormat: config.get('outputFormat', 'markdown'),
+      autoSaveKnowledge: config.get('autoSaveKnowledge', true),
+      mcpServerPort: config.get('mcpServerPort', 3000),
+    };
+  }
+
+  /**
+   * Register view providers
+   */
+  private registerViewProviders(): void {
+    // Research view
+    this.context.subscriptions.push(
+      vscode.window.registerTreeDataProvider(
+        'katashiro.research',
+        this.researchViewProvider
+      )
+    );
+
+    // Knowledge view
+    this.context.subscriptions.push(
+      vscode.window.registerTreeDataProvider(
+        'katashiro.knowledge',
+        this.knowledgeViewProvider
+      )
+    );
+
+    // History view
+    this.context.subscriptions.push(
+      vscode.window.registerTreeDataProvider(
+        'katashiro.history',
+        this.historyViewProvider
+      )
+    );
+  }
+}

package/src/ui/index.ts

@@ -0,0 +1,9 @@
+/**
+ * UI module exports
+ */
+
+export {
+  OutputChannelManager,
+  type LogLevel,
+} from './output-channel-manager.js';
+export { StatusBarManager, type StatusBarState } from './status-bar-manager.js';

package/src/ui/output-channel-manager.ts

@@ -0,0 +1,105 @@
+/**
+ * OutputChannelManager - VS Code output channel management
+ *
+ * @module katashiro
+ * @task TSK-073
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * Log level
+ */
+export type LogLevel = 'info' | 'warn' | 'error' | 'debug';
+
+/**
+ * OutputChannelManager
+ *
+ * Manages VS Code output channel for KATASHIRO
+ */
+export class OutputChannelManager {
+  private channel: vscode.OutputChannel;
+  private debugMode: boolean;
+
+  constructor(name = 'KATASHIRO') {
+    this.channel = vscode.window.createOutputChannel(name);
+    this.debugMode =
+      vscode.workspace.getConfiguration('katashiro').get('debug', false);
+  }
+
+  /**
+   * Log a message
+   */
+  log(message: string, level: LogLevel = 'info'): void {
+    const timestamp = new Date().toISOString();
+    const prefix = this.getLevelPrefix(level);
+    this.channel.appendLine(`[${timestamp}] ${prefix} ${message}`);
+  }
+
+  /**
+   * Log info message
+   */
+  info(message: string): void {
+    this.log(message, 'info');
+  }
+
+  /**
+   * Log warning message
+   */
+  warn(message: string): void {
+    this.log(message, 'warn');
+  }
+
+  /**
+   * Log error message
+   */
+  error(message: string): void {
+    this.log(message, 'error');
+  }
+
+  /**
+   * Log debug message (only if debug mode is enabled)
+   */
+  debug(message: string): void {
+    if (this.debugMode) {
+      this.log(message, 'debug');
+    }
+  }
+
+  /**
+   * Show the output channel
+   */
+  show(): void {
+    this.channel.show();
+  }
+
+  /**
+   * Clear the output channel
+   */
+  clear(): void {
+    this.channel.clear();
+  }
+
+  /**
+   * Dispose the output channel
+   */
+  dispose(): void {
+    this.channel.dispose();
+  }
+
+  /**
+   * Get level prefix
+   */
+  private getLevelPrefix(level: LogLevel): string {
+    switch (level) {
+      case 'info':
+        return 'INFO';
+      case 'warn':
+        return 'WARN';
+      case 'error':
+        return 'ERROR';
+      case 'debug':
+        return 'DEBUG';
+    }
+  }
+}

package/src/ui/status-bar-manager.ts

@@ -0,0 +1,157 @@
+/**
+ * StatusBarManager - VS Code status bar management
+ *
+ * @module katashiro
+ * @task TSK-073
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * Status bar state
+ */
+export type StatusBarState = 'idle' | 'working' | 'success' | 'error';
+
+/**
+ * StatusBarManager
+ *
+ * Manages VS Code status bar item for KATASHIRO
+ */
+export class StatusBarManager {
+  private statusBarItem: vscode.StatusBarItem;
+  private currentState: StatusBarState = 'idle';
+  private spinnerInterval: NodeJS.Timeout | null = null;
+  private spinnerFrames = ['$(sync~spin)', '$(loading~spin)'];
+  private spinnerIndex = 0;
+
+  constructor() {
+    this.statusBarItem = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Right,
+      100
+    );
+    this.statusBarItem.command = 'katashiro.webSearch';
+    this.setIdle();
+  }
+
+  /**
+   * Show the status bar item
+   */
+  show(): void {
+    this.statusBarItem.show();
+  }
+
+  /**
+   * Hide the status bar item
+   */
+  hide(): void {
+    this.statusBarItem.hide();
+  }
+
+  /**
+   * Dispose the status bar item
+   */
+  dispose(): void {
+    this.stopSpinner();
+    this.statusBarItem.dispose();
+  }
+
+  /**
+   * Get current state
+   */
+  getState(): StatusBarState {
+    return this.currentState;
+  }
+
+  /**
+   * Set idle state
+   */
+  setIdle(message = 'KATASHIRO'): void {
+    this.stopSpinner();
+    this.currentState = 'idle';
+    this.statusBarItem.text = `$(search) ${message}`;
+    this.statusBarItem.tooltip = 'Click to search';
+    this.statusBarItem.backgroundColor = undefined;
+  }
+
+  /**
+   * Set working state
+   */
+  setWorking(message = 'Working...'): void {
+    this.currentState = 'working';
+    this.statusBarItem.tooltip = message;
+    this.startSpinner(message);
+  }
+
+  /**
+   * Set success state
+   */
+  setSuccess(message = 'Done', autoResetMs = 3000): void {
+    this.stopSpinner();
+    this.currentState = 'success';
+    this.statusBarItem.text = `$(check) ${message}`;
+    this.statusBarItem.tooltip = message;
+    this.statusBarItem.backgroundColor = new vscode.ThemeColor(
+      'statusBarItem.prominentBackground'
+    );
+
+    if (autoResetMs > 0) {
+      setTimeout(() => {
+        if (this.currentState === 'success') {
+          this.setIdle();
+        }
+      }, autoResetMs);
+    }
+  }
+
+  /**
+   * Set error state
+   */
+  setError(message = 'Error', autoResetMs = 5000): void {
+    this.stopSpinner();
+    this.currentState = 'error';
+    this.statusBarItem.text = `$(error) ${message}`;
+    this.statusBarItem.tooltip = message;
+    this.statusBarItem.backgroundColor = new vscode.ThemeColor(
+      'statusBarItem.errorBackground'
+    );
+
+    if (autoResetMs > 0) {
+      setTimeout(() => {
+        if (this.currentState === 'error') {
+          this.setIdle();
+        }
+      }, autoResetMs);
+    }
+  }
+
+  /**
+   * Start spinner animation
+   */
+  private startSpinner(message: string): void {
+    this.stopSpinner();
+    this.updateSpinner(message);
+    this.spinnerInterval = setInterval(() => {
+      this.updateSpinner(message);
+    }, 500);
+  }
+
+  /**
+   * Update spinner frame
+   */
+  private updateSpinner(message: string): void {
+    const frame = this.spinnerFrames[this.spinnerIndex];
+    this.statusBarItem.text = `${frame} ${message}`;
+    this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+  }
+
+  /**
+   * Stop spinner animation
+   */
+  private stopSpinner(): void {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+    }
+    this.spinnerIndex = 0;
+  }
+}

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

@@ -0,0 +1,221 @@
+/**
+ * HistoryViewProvider - History panel tree view
+ *
+ * @module katashiro
+ * @task TSK-072
+ */
+
+import * as vscode from 'vscode';
+
+/**
+ * History entry type
+ */
+export type HistoryEntryType =
+  | 'search'
+  | 'analysis'
+  | 'summary'
+  | 'research'
+  | 'report';
+
+/**
+ * History entry
+ */
+export interface HistoryEntry {
+  id: string;
+  type: HistoryEntryType;
+  title: string;
+  timestamp: Date;
+  details?: string;
+}
+
+/**
+ * History item for tree view
+ */
+export class HistoryItem extends vscode.TreeItem {
+  constructor(
+    public readonly entry: HistoryEntry,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState
+  ) {
+    super(entry.title, collapsibleState);
+    this.description = this.formatTime(entry.timestamp);
+    this.tooltip = `${entry.type}: ${entry.title}\n${entry.details || ''}`;
+    this.contextValue = entry.type;
+
+    // Set icon based on type
+    switch (entry.type) {
+      case 'search':
+        this.iconPath = new vscode.ThemeIcon('search');
+        break;
+      case 'analysis':
+        this.iconPath = new vscode.ThemeIcon('pulse');
+        break;
+      case 'summary':
+        this.iconPath = new vscode.ThemeIcon('note');
+        break;
+      case 'research':
+        this.iconPath = new vscode.ThemeIcon('book');
+        break;
+      case 'report':
+        this.iconPath = new vscode.ThemeIcon('file-text');
+        break;
+    }
+  }
+
+  /**
+   * 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`;
+
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffDays < 7) return `${diffDays}d ago`;
+
+    return date.toLocaleDateString();
+  }
+}
+
+/**
+ * HistoryViewProvider
+ *
+ * Provides tree data for the History panel
+ */
+export class HistoryViewProvider
+  implements vscode.TreeDataProvider<HistoryItem>
+{
+  private _onDidChangeTreeData = new vscode.EventEmitter<
+    HistoryItem | undefined | null | void
+  >();
+  readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+  private history: HistoryEntry[] = [];
+  private maxEntries = 50;
+
+  /**
+   * Refresh the tree view
+   */
+  refresh(): void {
+    this._onDidChangeTreeData.fire();
+  }
+
+  /**
+   * Add a history entry
+   */
+  addEntry(
+    type: HistoryEntryType,
+    title: string,
+    details?: string
+  ): HistoryEntry {
+    const entry: HistoryEntry = {
+      id: this.generateId(),
+      type,
+      title,
+      timestamp: new Date(),
+      details,
+    };
+
+    this.history.unshift(entry);
+
+    // Limit history size
+    if (this.history.length > this.maxEntries) {
+      this.history = this.history.slice(0, this.maxEntries);
+    }
+
+    this.refresh();
+    return entry;
+  }
+
+  /**
+   * Clear all history
+   */
+  clear(): void {
+    this.history = [];
+    this.refresh();
+  }
+
+  /**
+   * Get entry by ID
+   */
+  getEntry(id: string): HistoryEntry | undefined {
+    return this.history.find((e) => e.id === id);
+  }
+
+  /**
+   * Get all entries
+   */
+  getAll(): HistoryEntry[] {
+    return [...this.history];
+  }
+
+  /**
+   * Get tree item
+   */
+  getTreeItem(element: HistoryItem): vscode.TreeItem {
+    return element;
+  }
+
+  /**
+   * Get children
+   */
+  getChildren(element?: HistoryItem): Thenable<HistoryItem[]> {
+    if (element) {
+      // No children for history items
+      return Promise.resolve([]);
+    }
+
+    // Root level - all history entries
+    if (this.history.length === 0) {
+      return Promise.resolve([]);
+    }
+
+    // Group by date
+    const today: HistoryEntry[] = [];
+    const yesterday: HistoryEntry[] = [];
+    const thisWeek: HistoryEntry[] = [];
+    const older: HistoryEntry[] = [];
+
+    const now = new Date();
+    const todayStart = new Date(
+      now.getFullYear(),
+      now.getMonth(),
+      now.getDate()
+    );
+    const yesterdayStart = new Date(todayStart.getTime() - 86400000);
+    const weekStart = new Date(todayStart.getTime() - 7 * 86400000);
+
+    for (const entry of this.history) {
+      const time = entry.timestamp.getTime();
+      if (time >= todayStart.getTime()) {
+        today.push(entry);
+      } else if (time >= yesterdayStart.getTime()) {
+        yesterday.push(entry);
+      } else if (time >= weekStart.getTime()) {
+        thisWeek.push(entry);
+      } else {
+        older.push(entry);
+      }
+    }
+
+    // Return all entries as flat list
+    return Promise.resolve(
+      this.history.map(
+        (entry) =>
+          new HistoryItem(entry, vscode.TreeItemCollapsibleState.None)
+      )
+    );
+  }
+
+  /**
+   * Generate unique ID
+   */
+  private generateId(): string {
+    return `history-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+}

package/src/views/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Views module exports
+ */
+
+export { ResearchViewProvider, ResearchItem } from './research-view-provider.js';
+export {
+  KnowledgeViewProvider,
+  KnowledgeItem,
+} from './knowledge-view-provider.js';
+export {
+  HistoryViewProvider,
+  HistoryItem,
+  type HistoryEntry,
+  type HistoryEntryType,
+} from './history-view-provider.js';