katashiro-vscode 0.2.0

package/package.json

@@ -0,0 +1,184 @@
+{
+  "name": "katashiro-vscode",
+  "displayName": "KATASHIRO",
+  "description": "AI-powered research assistant with web search, content analysis, and knowledge graph",
+  "version": "0.2.0",
+  "publisher": "nahisaho",
+  "icon": "media/icon.png",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nahisaho/katashiro"
+  },
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "categories": [
+    "Other",
+    "Data Science",
+    "Machine Learning"
+  ],
+  "keywords": [
+    "research",
+    "ai",
+    "knowledge graph",
+    "web search",
+    "content analysis",
+    "mcp",
+    "agent"
+  ],
+  "activationEvents": [
+    "onStartupFinished"
+  ],
+  "main": "./dist/extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "katashiro.webSearch",
+        "title": "KATASHIRO: Web Search",
+        "category": "KATASHIRO"
+      },
+      {
+        "command": "katashiro.analyzeContent",
+        "title": "KATASHIRO: Analyze Content",
+        "category": "KATASHIRO"
+      },
+      {
+        "command": "katashiro.generateSummary",
+        "title": "KATASHIRO: Generate Summary",
+        "category": "KATASHIRO"
+      },
+      {
+        "command": "katashiro.researchTopic",
+        "title": "KATASHIRO: Research Topic",
+        "category": "KATASHIRO"
+      },
+      {
+        "command": "katashiro.generateReport",
+        "title": "KATASHIRO: Generate Report",
+        "category": "KATASHIRO"
+      },
+      {
+        "command": "katashiro.showKnowledgeGraph",
+        "title": "KATASHIRO: Show Knowledge Graph",
+        "category": "KATASHIRO"
+      },
+      {
+        "command": "katashiro.startMcpServer",
+        "title": "KATASHIRO: Start MCP Server",
+        "category": "KATASHIRO"
+      }
+    ],
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "katashiro",
+          "title": "KATASHIRO",
+          "icon": "media/icon.svg"
+        }
+      ]
+    },
+    "views": {
+      "katashiro": [
+        {
+          "id": "katashiro.research",
+          "name": "Research"
+        },
+        {
+          "id": "katashiro.knowledge",
+          "name": "Knowledge Graph"
+        },
+        {
+          "id": "katashiro.history",
+          "name": "History"
+        }
+      ]
+    },
+    "configuration": {
+      "title": "KATASHIRO",
+      "properties": {
+        "katashiro.searchEngine": {
+          "type": "string",
+          "default": "duckduckgo",
+          "enum": [
+            "duckduckgo",
+            "google",
+            "bing"
+          ],
+          "description": "Default search engine for web searches"
+        },
+        "katashiro.maxSearchResults": {
+          "type": "number",
+          "default": 10,
+          "minimum": 1,
+          "maximum": 50,
+          "description": "Maximum number of search results to return"
+        },
+        "katashiro.outputFormat": {
+          "type": "string",
+          "default": "markdown",
+          "enum": [
+            "markdown",
+            "html",
+            "json"
+          ],
+          "description": "Default output format for reports"
+        },
+        "katashiro.autoSaveKnowledge": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically save research to knowledge graph"
+        },
+        "katashiro.mcpServerPort": {
+          "type": "number",
+          "default": 3000,
+          "description": "Port for MCP server HTTP transport"
+        }
+      }
+    },
+    "menus": {
+      "editor/context": [
+        {
+          "command": "katashiro.analyzeContent",
+          "when": "editorHasSelection",
+          "group": "katashiro"
+        },
+        {
+          "command": "katashiro.generateSummary",
+          "when": "editorHasSelection",
+          "group": "katashiro"
+        }
+      ],
+      "view/title": [
+        {
+          "command": "katashiro.webSearch",
+          "when": "view == katashiro.research",
+          "group": "navigation"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "vscode:prepublish": "npm run build",
+    "build": "tsc",
+    "watch": "tsc -watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "package": "vsce package",
+    "publish": "vsce publish"
+  },
+  "dependencies": {
+    "@nahisaho/katashiro-core": "*",
+    "@nahisaho/katashiro-collector": "*",
+    "@nahisaho/katashiro-analyzer": "*",
+    "@nahisaho/katashiro-generator": "*",
+    "@nahisaho/katashiro-knowledge": "*",
+    "@nahisaho/katashiro-feedback": "*",
+    "@nahisaho/katashiro-mcp-server": "*"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.85.0",
+    "@vscode/vsce": "^2.22.0"
+  },
+  "author": "nahisaho",
+  "license": "MIT"
+}

package/src/commands/command-manager.ts

@@ -0,0 +1,452 @@
+/**
+ * CommandManager - VS Code command registration and handling
+ *
+ * @module katashiro
+ * @task TSK-071
+ */
+
+import * as vscode from 'vscode';
+import type { OutputChannelManager } from '../ui/output-channel-manager.js';
+
+/**
+ * CommandManager
+ *
+ * Manages registration and execution of VS Code commands
+ */
+export class CommandManager {
+  constructor(
+    private readonly context: vscode.ExtensionContext,
+    private readonly output: OutputChannelManager
+  ) {}
+
+  /**
+   * Register all commands
+   */
+  registerAll(): void {
+    this.register('katashiro.webSearch', this.webSearch.bind(this));
+    this.register('katashiro.analyzeContent', this.analyzeContent.bind(this));
+    this.register('katashiro.generateSummary', this.generateSummary.bind(this));
+    this.register('katashiro.researchTopic', this.researchTopic.bind(this));
+    this.register('katashiro.generateReport', this.generateReport.bind(this));
+    this.register(
+      'katashiro.showKnowledgeGraph',
+      this.showKnowledgeGraph.bind(this)
+    );
+    this.register('katashiro.startMcpServer', this.startMcpServer.bind(this));
+  }
+
+  /**
+   * Register a command
+   */
+  private register(
+    command: string,
+    callback: (...args: unknown[]) => Promise<void>
+  ): void {
+    const disposable = vscode.commands.registerCommand(command, callback);
+    this.context.subscriptions.push(disposable);
+  }
+
+  /**
+   * Web Search command
+   */
+  private async webSearch(): Promise<void> {
+    const query = await vscode.window.showInputBox({
+      prompt: 'Enter search query',
+      placeHolder: 'Search the web...',
+    });
+
+    if (!query) {
+      return;
+    }
+
+    this.output.log(`Web search: ${query}`);
+
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: 'KATASHIRO: Searching...',
+        cancellable: false,
+      },
+      async () => {
+        try {
+          // TODO: Integrate with WebSearchClient
+          const results = await this.performWebSearch(query);
+
+          // Show results in new document
+          const doc = await vscode.workspace.openTextDocument({
+            content: this.formatSearchResults(query, results),
+            language: 'markdown',
+          });
+          await vscode.window.showTextDocument(doc);
+
+          this.output.log(`Search completed: ${results.length} results`);
+        } catch (error) {
+          this.handleError('Web search failed', error);
+        }
+      }
+    );
+  }
+
+  /**
+   * Analyze Content command
+   */
+  private async analyzeContent(): Promise<void> {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+      vscode.window.showWarningMessage('No active editor');
+      return;
+    }
+
+    const selection = editor.selection;
+    const content = selection.isEmpty
+      ? editor.document.getText()
+      : editor.document.getText(selection);
+
+    if (!content.trim()) {
+      vscode.window.showWarningMessage('No content to analyze');
+      return;
+    }
+
+    this.output.log('Analyzing content...');
+
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: 'KATASHIRO: Analyzing...',
+        cancellable: false,
+      },
+      async () => {
+        try {
+          // TODO: Integrate with TextAnalyzer
+          const analysis = await this.performContentAnalysis(content);
+
+          // Show analysis in new document
+          const doc = await vscode.workspace.openTextDocument({
+            content: this.formatAnalysis(analysis),
+            language: 'markdown',
+          });
+          await vscode.window.showTextDocument(doc, vscode.ViewColumn.Beside);
+
+          this.output.log('Content analysis completed');
+        } catch (error) {
+          this.handleError('Content analysis failed', error);
+        }
+      }
+    );
+  }
+
+  /**
+   * Generate Summary command
+   */
+  private async generateSummary(): Promise<void> {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+      vscode.window.showWarningMessage('No active editor');
+      return;
+    }
+
+    const selection = editor.selection;
+    const content = selection.isEmpty
+      ? editor.document.getText()
+      : editor.document.getText(selection);
+
+    if (!content.trim()) {
+      vscode.window.showWarningMessage('No content to summarize');
+      return;
+    }
+
+    const style = await vscode.window.showQuickPick(
+      ['brief', 'detailed', 'bullet'],
+      {
+        placeHolder: 'Select summary style',
+      }
+    );
+
+    if (!style) {
+      return;
+    }
+
+    this.output.log(`Generating ${style} summary...`);
+
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: 'KATASHIRO: Generating summary...',
+        cancellable: false,
+      },
+      async () => {
+        try {
+          // TODO: Integrate with SummaryGenerator
+          const summary = await this.performSummaryGeneration(content, style);
+
+          // Show summary in new document
+          const doc = await vscode.workspace.openTextDocument({
+            content: summary,
+            language: 'markdown',
+          });
+          await vscode.window.showTextDocument(doc, vscode.ViewColumn.Beside);
+
+          this.output.log('Summary generation completed');
+        } catch (error) {
+          this.handleError('Summary generation failed', error);
+        }
+      }
+    );
+  }
+
+  /**
+   * Research Topic command
+   */
+  private async researchTopic(): Promise<void> {
+    const topic = await vscode.window.showInputBox({
+      prompt: 'Enter topic to research',
+      placeHolder: 'Research topic...',
+    });
+
+    if (!topic) {
+      return;
+    }
+
+    const depth = await vscode.window.showQuickPick(
+      ['shallow', 'moderate', 'deep'],
+      {
+        placeHolder: 'Select research depth',
+      }
+    );
+
+    if (!depth) {
+      return;
+    }
+
+    this.output.log(`Researching topic: ${topic} (depth: ${depth})`);
+
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: 'KATASHIRO: Researching...',
+        cancellable: true,
+      },
+      async (progress, token) => {
+        try {
+          progress.report({ message: 'Searching web...' });
+
+          // TODO: Full research pipeline
+          const results = await this.performResearch(topic, depth, token);
+
+          if (token.isCancellationRequested) {
+            this.output.log('Research cancelled');
+            return;
+          }
+
+          // Show results
+          const doc = await vscode.workspace.openTextDocument({
+            content: this.formatResearchResults(topic, results),
+            language: 'markdown',
+          });
+          await vscode.window.showTextDocument(doc);
+
+          this.output.log('Research completed');
+        } catch (error) {
+          this.handleError('Research failed', error);
+        }
+      }
+    );
+  }
+
+  /**
+   * Generate Report command
+   */
+  private async generateReport(): Promise<void> {
+    const topic = await vscode.window.showInputBox({
+      prompt: 'Enter report topic',
+      placeHolder: 'Report topic...',
+    });
+
+    if (!topic) {
+      return;
+    }
+
+    const format = await vscode.window.showQuickPick(
+      ['markdown', 'html', 'pdf'],
+      {
+        placeHolder: 'Select output format',
+      }
+    );
+
+    if (!format) {
+      return;
+    }
+
+    this.output.log(`Generating report: ${topic} (format: ${format})`);
+
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: 'KATASHIRO: Generating report...',
+        cancellable: false,
+      },
+      async () => {
+        try {
+          // TODO: Integrate with ReportGenerator
+          const report = await this.performReportGeneration(topic, format);
+
+          // Show report
+          const language = format === 'html' ? 'html' : 'markdown';
+          const doc = await vscode.workspace.openTextDocument({
+            content: report,
+            language,
+          });
+          await vscode.window.showTextDocument(doc);
+
+          this.output.log('Report generation completed');
+        } catch (error) {
+          this.handleError('Report generation failed', error);
+        }
+      }
+    );
+  }
+
+  /**
+   * Show Knowledge Graph command
+   */
+  private async showKnowledgeGraph(): Promise<void> {
+    this.output.log('Opening knowledge graph viewer...');
+
+    // TODO: Implement webview for knowledge graph visualization
+    vscode.window.showInformationMessage(
+      'KATASHIRO: Knowledge Graph viewer coming soon!'
+    );
+  }
+
+  /**
+   * Start MCP Server command
+   */
+  private async startMcpServer(): Promise<void> {
+    this.output.log('Starting MCP server...');
+
+    try {
+      // TODO: Start MCP server in background
+      vscode.window.showInformationMessage(
+        'KATASHIRO: MCP Server started on stdio'
+      );
+      this.output.log('MCP server started');
+    } catch (error) {
+      this.handleError('Failed to start MCP server', error);
+    }
+  }
+
+  // Helper methods (placeholder implementations)
+
+  private async performWebSearch(
+    query: string
+  ): Promise<Array<{ title: string; url: string; snippet: string }>> {
+    // Placeholder - will integrate with WebSearchClient
+    return [
+      {
+        title: `Result 1 for: ${query}`,
+        url: 'https://example.com/1',
+        snippet: 'This is a sample search result snippet...',
+      },
+      {
+        title: `Result 2 for: ${query}`,
+        url: 'https://example.com/2',
+        snippet: 'Another sample search result snippet...',
+      },
+    ];
+  }
+
+  private formatSearchResults(
+    query: string,
+    results: Array<{ title: string; url: string; snippet: string }>
+  ): string {
+    let md = `# Search Results: ${query}\n\n`;
+    md += `Found ${results.length} results\n\n`;
+
+    for (const result of results) {
+      md += `## [${result.title}](${result.url})\n\n`;
+      md += `${result.snippet}\n\n`;
+      md += '---\n\n';
+    }
+
+    return md;
+  }
+
+  private async performContentAnalysis(content: string): Promise<{
+    wordCount: number;
+    entities: string[];
+    topics: string[];
+    sentiment: string;
+  }> {
+    // Placeholder - will integrate with TextAnalyzer
+    return {
+      wordCount: content.split(/\s+/).length,
+      entities: ['Entity 1', 'Entity 2'],
+      topics: ['Topic 1', 'Topic 2'],
+      sentiment: 'neutral',
+    };
+  }
+
+  private formatAnalysis(analysis: {
+    wordCount: number;
+    entities: string[];
+    topics: string[];
+    sentiment: string;
+  }): string {
+    let md = '# Content Analysis\n\n';
+    md += `**Word Count:** ${analysis.wordCount}\n\n`;
+    md += `**Sentiment:** ${analysis.sentiment}\n\n`;
+    md += '## Entities\n\n';
+    md += analysis.entities.map((e) => `- ${e}`).join('\n');
+    md += '\n\n## Topics\n\n';
+    md += analysis.topics.map((t) => `- ${t}`).join('\n');
+    return md;
+  }
+
+  private async performSummaryGeneration(
+    content: string,
+    style: string
+  ): Promise<string> {
+    // Placeholder - will integrate with SummaryGenerator
+    const preview = content.substring(0, 200);
+    return `# Summary (${style})\n\n${preview}...\n\n*Generated by KATASHIRO*`;
+  }
+
+  private async performResearch(
+    topic: string,
+    depth: string,
+    _token: vscode.CancellationToken
+  ): Promise<{ summary: string; sources: string[] }> {
+    // Placeholder - will integrate with full research pipeline
+    return {
+      summary: `Research findings for "${topic}" at ${depth} depth...`,
+      sources: ['https://example.com/source1', 'https://example.com/source2'],
+    };
+  }
+
+  private formatResearchResults(
+    topic: string,
+    results: { summary: string; sources: string[] }
+  ): string {
+    let md = `# Research: ${topic}\n\n`;
+    md += `## Summary\n\n${results.summary}\n\n`;
+    md += '## Sources\n\n';
+    md += results.sources.map((s) => `- ${s}`).join('\n');
+    md += '\n\n*Generated by KATASHIRO*';
+    return md;
+  }
+
+  private async performReportGeneration(
+    topic: string,
+    format: string
+  ): Promise<string> {
+    // Placeholder - will integrate with ReportGenerator
+    return `# Report: ${topic}\n\nFormat: ${format}\n\n## Introduction\n\n...\n\n## Conclusion\n\n...\n\n*Generated by KATASHIRO*`;
+  }
+
+  private handleError(message: string, error: unknown): void {
+    const errorMessage =
+      error instanceof Error ? error.message : 'Unknown error';
+    this.output.error(`${message}: ${errorMessage}`);
+    vscode.window.showErrorMessage(`KATASHIRO: ${message}`);
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Commands module exports
+ */
+
+export { CommandManager } from './command-manager.js';

package/src/extension.ts

@@ -0,0 +1,48 @@
+/**
+ * KATASHIRO VS Code Extension
+ *
+ * Main extension entry point
+ *
+ * @module katashiro
+ * @task TSK-070
+ */
+
+import * as vscode from 'vscode';
+import { KatashiroExtension } from './katashiro-extension.js';
+
+let extension: KatashiroExtension | undefined;
+
+/**
+ * Activate the extension
+ */
+export async function activate(
+  context: vscode.ExtensionContext
+): Promise<void> {
+  console.log('KATASHIRO extension activating...');
+
+  try {
+    extension = new KatashiroExtension(context);
+    await extension.activate();
+
+    console.log('KATASHIRO extension activated successfully');
+  } catch (error) {
+    console.error('Failed to activate KATASHIRO extension:', error);
+    vscode.window.showErrorMessage(
+      `KATASHIRO: Failed to activate - ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
+
+/**
+ * Deactivate the extension
+ */
+export async function deactivate(): Promise<void> {
+  console.log('KATASHIRO extension deactivating...');
+
+  if (extension) {
+    await extension.deactivate();
+    extension = undefined;
+  }
+
+  console.log('KATASHIRO extension deactivated');
+}