@nahisaho/shikigami 1.22.0 → 1.23.0

package/CHANGELOG.md

@@ -5,6 +5,51 @@ All notable changes to SHIKIGAMI will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.23.0] - 2026-01-27
+
+### Added
+
+- **MCPツール: プロジェクトコンテキスト管理**
+  - `set_project`: アクティブなプロジェクトディレクトリを設定
+    - `projectPath`: 手動でプロジェクトパスを指定
+    - `autoDetect`: projects/内の最新プロジェクトを自動検出
+  - `get_project`: 現在のプロジェクト情報を取得
+
+- **MCPツール: ファイル永続化機能**
+  - `save_prompt`: プロンプトをprompts/に保存
+    - タイプ: original（元プロンプト）, structured（構造化後）, refinement（修正）
+    - 自動フロントマター付与（timestamp, project_id, type）
+  - `save_research`: 検索結果をresearch/に保存
+    - ソース種別: search（Web検索）, visit（ページ訪問）, manual（手動）
+    - Markdown/JSON両形式対応
+    - クエリ情報をメタデータとして保存
+
+- **新規モジュール**
+  - `tools/project.ts`: プロジェクト管理機能（検証、パス解決、自動検出）
+  - `tools/save.ts`: ファイル保存機能（プロンプト、リサーチ）
+
+- **CLIコマンド: upgrade/update**
+  - `npx shikigami upgrade` または `npx shikigami update` で最新版にアップグレード
+  - 内部的に `npx shikigami init --force` と同じ動作
+  - 既存ファイルを上書きしてSHIKIGAMIを更新
+
+### Fixed
+
+- **プロンプトがprompts/に保存されない問題を修正**
+  - 原因: MCPサーバーにファイル書き込みツールが存在しなかった
+  - 対策: `save_prompt`ツールを実装
+
+- **検索結果がresearch/に保存されない問題を修正**
+  - 原因: searchツールは結果を返すだけで永続化機能がなかった
+  - 対策: `save_research`ツールを実装
+
+### Changed
+
+- **index.ts**: 新規ツール定義（4ツール）とハンドラー追加
+- **MCPサーバー**: ツール総数 7→11 に増加
+
+---
+
 ## [1.22.0] - 2026-01-27
 
 ### Added

package/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nahisaho/shikigami-mcp-server",
-  "version": "1.16.6",
+  "version": "1.23.0",
   "description": "SHIKIGAMI MCP Server - Deep Research tools with search fallback mechanism",
   "type": "module",
   "main": "dist/index.js",

package/mcp-server/src/index.ts

@@ -27,9 +27,131 @@ import {
   type SimilarityResult,
   type SearchResult as SemanticSearchResult,
 } from './tools/embedding.js';
+import {
+  setActiveProject,
+  getProjectInfo,
+  detectLatestProject,
+} from './tools/project.js';
+import {
+  savePrompt,
+  saveResearch,
+  saveResearchJson,
+  type SavePromptOptions,
+  type SaveResearchOptions,
+} from './tools/save.js';
 
 // Tool definitions
 const TOOLS: Tool[] = [
+  // Project Management Tools (v1.23.0)
+  {
+    name: 'set_project',
+    description: `アクティブなプロジェクトディレクトリを設定。
+save_prompt, save_researchの前に必ず実行。
+プロジェクトパスはnpx shikigami newで作成されたフォルダを指定。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: {
+          type: 'string',
+          description: 'プロジェクトディレクトリの絶対パスまたは相対パス（例: projects/pj00001_MyProject_20260127）',
+        },
+        autoDetect: {
+          type: 'boolean',
+          default: false,
+          description: 'trueの場合、projects/内の最新プロジェクトを自動検出',
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: 'get_project',
+    description: `現在のアクティブなプロジェクト情報を取得。
+プロジェクトID、パス、各ディレクトリの情報を返却。`,
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: 'save_prompt',
+    description: `プロンプトをプロジェクトのprompts/ディレクトリに保存。
+元のプロンプト、構造化プロンプト、修正履歴を記録。
+set_projectでプロジェクトを設定してから使用。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: '保存するプロンプト内容',
+        },
+        type: {
+          type: 'string',
+          enum: ['original', 'structured', 'refinement'],
+          description: 'プロンプトの種類（original: 元のプロンプト, structured: 構造化後, refinement: 修正）',
+        },
+        filename: {
+          type: 'string',
+          description: 'ファイル名（省略時は自動生成）',
+        },
+        version: {
+          type: 'number',
+          description: '修正バージョン番号（refinementタイプの場合）',
+        },
+        metadata: {
+          type: 'object',
+          description: '追加のメタデータ',
+        },
+      },
+      required: ['content', 'type'],
+    },
+  },
+  {
+    name: 'save_research',
+    description: `検索結果や調査内容をプロジェクトのresearch/ディレクトリに保存。
+Web検索結果、ページ訪問結果、手動メモを記録。
+set_projectでプロジェクトを設定してから使用。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: '保存する調査内容（Markdown形式推奨）',
+        },
+        query: {
+          type: 'string',
+          description: '検索クエリ（ファイル名に使用）',
+        },
+        source: {
+          type: 'string',
+          enum: ['search', 'visit', 'manual'],
+          default: 'manual',
+          description: '情報ソース（search: Web検索, visit: ページ訪問, manual: 手動入力）',
+        },
+        filename: {
+          type: 'string',
+          description: 'ファイル名（省略時は自動生成）',
+        },
+        format: {
+          type: 'string',
+          enum: ['markdown', 'json'],
+          default: 'markdown',
+          description: '保存形式',
+        },
+        data: {
+          type: 'object',
+          description: 'JSON形式で保存する場合のデータ（format=jsonの場合）',
+        },
+        metadata: {
+          type: 'object',
+          description: '追加のメタデータ',
+        },
+      },
+      required: ['content'],
+    },
+  },
+  // Search & Visit Tools
   {
     name: 'search',
     description: `バッチWeb検索を実行（DuckDuckGo使用）。
@@ -244,6 +366,141 @@ server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest)
 
   try {
     switch (name) {
+      // Project Management Handlers (v1.23.0)
+      case 'set_project': {
+        const projectPath = args?.projectPath as string | undefined;
+        const autoDetect = args?.autoDetect as boolean | undefined;
+
+        let targetPath: string;
+
+        if (autoDetect) {
+          const detected = detectLatestProject();
+          if (!detected) {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: JSON.stringify({
+                    success: false,
+                    error: 'No project found in projects/ directory. Create one with: npx shikigami new <ProjectName>',
+                  }, null, 2),
+                },
+              ],
+              isError: true,
+            };
+          }
+          targetPath = detected;
+        } else if (projectPath) {
+          targetPath = projectPath;
+        } else {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify({
+                  success: false,
+                  error: 'Either projectPath or autoDetect=true is required',
+                }, null, 2),
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const project = setActiveProject(targetPath);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                message: `Active project set to: ${project.projectPath}`,
+                project: getProjectInfo(),
+              }, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'get_project': {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(getProjectInfo(), null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'save_prompt': {
+        const content = args?.content as string;
+        const type = args?.type as 'original' | 'structured' | 'refinement';
+        const filename = args?.filename as string | undefined;
+        const version = args?.version as number | undefined;
+        const metadata = args?.metadata as Record<string, unknown> | undefined;
+
+        const result = await savePrompt(content, {
+          type,
+          filename,
+          version,
+          metadata,
+        });
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'save_research': {
+        const content = args?.content as string;
+        const query = args?.query as string | undefined;
+        const source = args?.source as 'search' | 'visit' | 'manual' | undefined;
+        const filename = args?.filename as string | undefined;
+        const format = args?.format as 'markdown' | 'json' | undefined;
+        const data = args?.data as unknown;
+        const metadata = args?.metadata as Record<string, unknown> | undefined;
+
+        if (format === 'json' && data) {
+          const result = await saveResearchJson(data, {
+            query,
+            source,
+            filename,
+            metadata,
+          });
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+              },
+            ],
+          };
+        }
+
+        const result = await saveResearch(content, {
+          query,
+          source,
+          filename,
+          metadata,
+        });
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      // Search & Visit Handlers
       case 'search': {
         const queryInput = args?.query as string | string[];
         const maxResults = (args?.maxResults as number) ?? 10;

package/mcp-server/src/tools/__tests__/project.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Project Management Module Tests
+ * v1.23.0 - REQ-SHIKIGAMI-016
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  setActiveProject,
+  getActiveProject,
+  hasActiveProject,
+  clearActiveProject,
+  getProjectSubdirectory,
+  getProjectInfo,
+  isValidProjectDirectory,
+  detectLatestProject,
+} from '../project.js';
+
+// Mock fs module
+vi.mock('fs');
+
+describe('Project Management Module', () => {
+  const mockProjectPath = '/test/projects/pj00001_TestProject_20260127';
+
+  beforeEach(() => {
+    clearActiveProject();
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    clearActiveProject();
+  });
+
+  describe('isValidProjectDirectory', () => {
+    it('should return true for valid project directory', () => {
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        const pathStr = String(p);
+        return (
+          pathStr.includes('prompts') ||
+          pathStr.includes('research') ||
+          pathStr.includes('reports') ||
+          pathStr.includes('manifest.yaml')
+        );
+      });
+
+      expect(isValidProjectDirectory(mockProjectPath)).toBe(true);
+    });
+
+    it('should return false if prompts directory is missing', () => {
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        const pathStr = String(p);
+        return !pathStr.includes('prompts');
+      });
+
+      expect(isValidProjectDirectory(mockProjectPath)).toBe(false);
+    });
+
+    it('should return false if manifest.yaml is missing', () => {
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        const pathStr = String(p);
+        return (
+          pathStr.includes('prompts') ||
+          pathStr.includes('research') ||
+          pathStr.includes('reports')
+        );
+      });
+
+      expect(isValidProjectDirectory(mockProjectPath)).toBe(false);
+    });
+  });
+
+  describe('setActiveProject', () => {
+    it('should set active project successfully', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+
+      const project = setActiveProject(mockProjectPath);
+
+      expect(project.projectPath).toBe(mockProjectPath);
+      expect(project.projectId).toBe('pj00001');
+      expect(project.projectName).toBe('TestProject');
+      expect(project.promptsDir).toBe(path.join(mockProjectPath, 'prompts'));
+      expect(project.researchDir).toBe(path.join(mockProjectPath, 'research'));
+      expect(project.reportsDir).toBe(path.join(mockProjectPath, 'reports'));
+    });
+
+    it('should throw error if directory does not exist', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      expect(() => setActiveProject('/nonexistent')).toThrow(
+        'Project directory not found'
+      );
+    });
+
+    it('should throw error if directory is invalid', () => {
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        const pathStr = String(p);
+        // Path exists but subdirectories don't
+        return pathStr === mockProjectPath;
+      });
+
+      expect(() => setActiveProject(mockProjectPath)).toThrow(
+        'Invalid project directory'
+      );
+    });
+  });
+
+  describe('getActiveProject', () => {
+    it('should return null when no project is active', () => {
+      expect(getActiveProject()).toBeNull();
+    });
+
+    it('should return active project when set', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      setActiveProject(mockProjectPath);
+
+      const project = getActiveProject();
+      expect(project).not.toBeNull();
+      expect(project?.projectId).toBe('pj00001');
+    });
+  });
+
+  describe('hasActiveProject', () => {
+    it('should return false when no project is active', () => {
+      expect(hasActiveProject()).toBe(false);
+    });
+
+    it('should return true when project is active', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      setActiveProject(mockProjectPath);
+
+      expect(hasActiveProject()).toBe(true);
+    });
+  });
+
+  describe('clearActiveProject', () => {
+    it('should clear active project', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      setActiveProject(mockProjectPath);
+      expect(hasActiveProject()).toBe(true);
+
+      clearActiveProject();
+      expect(hasActiveProject()).toBe(false);
+    });
+  });
+
+  describe('getProjectSubdirectory', () => {
+    it('should throw error when no project is active', () => {
+      expect(() => getProjectSubdirectory('prompts')).toThrow(
+        'No active project'
+      );
+    });
+
+    it('should return correct subdirectory path', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      setActiveProject(mockProjectPath);
+
+      expect(getProjectSubdirectory('prompts')).toBe(
+        path.join(mockProjectPath, 'prompts')
+      );
+      expect(getProjectSubdirectory('research')).toBe(
+        path.join(mockProjectPath, 'research')
+      );
+      expect(getProjectSubdirectory('reports')).toBe(
+        path.join(mockProjectPath, 'reports')
+      );
+    });
+  });
+
+  describe('getProjectInfo', () => {
+    it('should return inactive status when no project is active', () => {
+      const info = getProjectInfo();
+      expect(info.active).toBe(false);
+      expect(info.message).toContain('No active project');
+    });
+
+    it('should return full project info when active', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      setActiveProject(mockProjectPath);
+
+      const info = getProjectInfo();
+      expect(info.active).toBe(true);
+      expect(info.projectId).toBe('pj00001');
+      expect(info.projectName).toBe('TestProject');
+      expect(info.directories).toBeDefined();
+    });
+  });
+
+  describe('detectLatestProject', () => {
+    it('should return null if projects directory does not exist', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      expect(detectLatestProject('/test')).toBeNull();
+    });
+
+    it('should return latest project path', () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readdirSync).mockReturnValue([
+        { name: 'pj00001_Old_20260101', isDirectory: () => true },
+        { name: 'pj00002_New_20260127', isDirectory: () => true },
+        { name: '.hidden', isDirectory: () => true },
+      ] as unknown as fs.Dirent[]);
+      vi.mocked(fs.statSync).mockImplementation((p) => {
+        const pathStr = String(p);
+        if (pathStr.includes('pj00002')) {
+          return { mtime: new Date('2026-01-27') } as fs.Stats;
+        }
+        return { mtime: new Date('2026-01-01') } as fs.Stats;
+      });
+
+      const result = detectLatestProject('/test');
+      expect(result).toContain('pj00002_New_20260127');
+    });
+  });
+});

package/mcp-server/src/tools/__tests__/save.test.ts

@@ -0,0 +1,233 @@
+/**
+ * Save Module Tests
+ * v1.23.0 - REQ-SHIKIGAMI-016
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  savePrompt,
+  saveResearch,
+  saveResearchJson,
+  saveToProject,
+} from '../save.js';
+import {
+  setActiveProject,
+  clearActiveProject,
+} from '../project.js';
+
+// Mock fs module
+vi.mock('fs');
+
+// Mock project module to provide controlled active project
+vi.mock('../project.js', async () => {
+  const actual = await vi.importActual<typeof import('../project.js')>('../project.js');
+  return {
+    ...actual,
+    hasActiveProject: vi.fn(),
+    getActiveProject: vi.fn(),
+  };
+});
+
+import { hasActiveProject, getActiveProject } from '../project.js';
+
+describe('Save Module', () => {
+  const mockProject = {
+    projectPath: '/test/projects/pj00001_Test_20260127',
+    projectId: 'pj00001',
+    projectName: 'Test',
+    promptsDir: '/test/projects/pj00001_Test_20260127/prompts',
+    researchDir: '/test/projects/pj00001_Test_20260127/research',
+    reportsDir: '/test/projects/pj00001_Test_20260127/reports',
+    manifestPath: '/test/projects/pj00001_Test_20260127/manifest.yaml',
+  };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(hasActiveProject).mockReturnValue(true);
+    vi.mocked(getActiveProject).mockReturnValue(mockProject);
+    vi.mocked(fs.writeFileSync).mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('savePrompt', () => {
+    it('should throw error when no active project', async () => {
+      vi.mocked(hasActiveProject).mockReturnValue(false);
+
+      await expect(
+        savePrompt('test content', { type: 'original' })
+      ).rejects.toThrow('No active project');
+    });
+
+    it('should save original prompt with correct format', async () => {
+      const result = await savePrompt('My original prompt', {
+        type: 'original',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toContain('prompts');
+      expect(result.filePath).toContain('original-prompt');
+      expect(fs.writeFileSync).toHaveBeenCalled();
+
+      // Check content includes frontmatter
+      const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+      const content = writeCall[1] as string;
+      expect(content).toContain('---');
+      expect(content).toContain('type: "original"');
+      expect(content).toContain('project_id: "pj00001"');
+      expect(content).toContain('My original prompt');
+    });
+
+    it('should save structured prompt with correct format', async () => {
+      const result = await savePrompt('Structured prompt content', {
+        type: 'structured',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toContain('structured-prompt');
+
+      const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+      const content = writeCall[1] as string;
+      expect(content).toContain('type: "structured"');
+    });
+
+    it('should save refinement with version number', async () => {
+      const result = await savePrompt('Refined prompt', {
+        type: 'refinement',
+        version: 2,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toContain('refinement-2');
+
+      const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+      const content = writeCall[1] as string;
+      expect(content).toContain('version: 2');
+    });
+
+    it('should use custom filename when provided', async () => {
+      const result = await savePrompt('Content', {
+        type: 'original',
+        filename: 'custom-name.md',
+      });
+
+      expect(result.filePath).toContain('custom-name');
+    });
+  });
+
+  describe('saveResearch', () => {
+    it('should throw error when no active project', async () => {
+      vi.mocked(hasActiveProject).mockReturnValue(false);
+
+      await expect(saveResearch('test content', {})).rejects.toThrow(
+        'No active project'
+      );
+    });
+
+    it('should save search result with query info', async () => {
+      const result = await saveResearch('Search results here', {
+        query: 'TypeScript best practices',
+        source: 'search',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toContain('research');
+      expect(result.filePath).toContain('search');
+
+      const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+      const content = writeCall[1] as string;
+      expect(content).toContain('source: "search"');
+      expect(content).toContain('query: "TypeScript best practices"');
+    });
+
+    it('should save visit result', async () => {
+      const result = await saveResearch('Page content', {
+        source: 'visit',
+        query: 'example.com',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toContain('visit');
+    });
+
+    it('should save manual notes', async () => {
+      const result = await saveResearch('Manual notes', {
+        source: 'manual',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toContain('manual');
+    });
+  });
+
+  describe('saveResearchJson', () => {
+    it('should save JSON data with metadata', async () => {
+      const data = {
+        results: [
+          { title: 'Result 1', url: 'https://example.com/1' },
+          { title: 'Result 2', url: 'https://example.com/2' },
+        ],
+      };
+
+      const result = await saveResearchJson(data, {
+        query: 'test query',
+        source: 'search',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toContain('.json');
+
+      const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+      const content = writeCall[1] as string;
+      const parsed = JSON.parse(content);
+      expect(parsed.data).toEqual(data);
+      expect(parsed.query).toBe('test query');
+      expect(parsed.source).toBe('search');
+    });
+  });
+
+  describe('saveToProject', () => {
+    it('should save to prompts directory', async () => {
+      const result = await saveToProject('content', 'prompts', 'test.md');
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toBe(
+        '/test/projects/pj00001_Test_20260127/prompts/test.md'
+      );
+    });
+
+    it('should save to research directory', async () => {
+      const result = await saveToProject('content', 'research', 'test.md');
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toBe(
+        '/test/projects/pj00001_Test_20260127/research/test.md'
+      );
+    });
+
+    it('should save to reports directory', async () => {
+      const result = await saveToProject('content', 'reports', 'test.md');
+
+      expect(result.success).toBe(true);
+      expect(result.filePath).toBe(
+        '/test/projects/pj00001_Test_20260127/reports/test.md'
+      );
+    });
+
+    it('should sanitize filename', async () => {
+      const result = await saveToProject(
+        'content',
+        'prompts',
+        'my file<>:"/\\|?*.md'
+      );
+
+      expect(result.filePath).not.toContain('<');
+      expect(result.filePath).not.toContain('>');
+      expect(result.filePath).not.toContain(':');
+    });
+  });
+});

package/mcp-server/src/tools/project.ts

@@ -0,0 +1,211 @@
+/**
+ * Project Management Module
+ * v1.23.0 - REQ-SHIKIGAMI-016: プロジェクトコンテキスト管理
+ *
+ * アクティブなプロジェクトディレクトリを管理し、
+ * 他のツール（save_prompt, save_research）が使用するパスを提供
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// アクティブなプロジェクト情報
+interface ActiveProject {
+  projectPath: string;
+  projectId: string;
+  projectName: string;
+  promptsDir: string;
+  researchDir: string;
+  reportsDir: string;
+  manifestPath: string;
+}
+
+// グローバルな現在のプロジェクト
+let currentProject: ActiveProject | null = null;
+
+/**
+ * プロジェクトディレクトリが有効かどうか検証
+ */
+export function isValidProjectDirectory(projectPath: string): boolean {
+  // 必須ディレクトリの存在チェック
+  const requiredDirs = ['prompts', 'research', 'reports'];
+  const requiredFiles = ['manifest.yaml'];
+
+  for (const dir of requiredDirs) {
+    const dirPath = path.join(projectPath, dir);
+    if (!fs.existsSync(dirPath)) {
+      return false;
+    }
+  }
+
+  // manifest.yamlまたはmanifest.ymlの存在チェック
+  const manifestYaml = path.join(projectPath, 'manifest.yaml');
+  const manifestYml = path.join(projectPath, 'manifest.yml');
+  if (!fs.existsSync(manifestYaml) && !fs.existsSync(manifestYml)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * プロジェクトパスからプロジェクト情報を抽出
+ */
+function extractProjectInfo(projectPath: string): { projectId: string; projectName: string } {
+  const dirName = path.basename(projectPath);
+  // pjXXXXX_ProjectName_YYYYMMDD 形式をパース
+  const match = dirName.match(/^(pj\d{5})_(.+?)_\d{8}$/);
+
+  if (match) {
+    return {
+      projectId: match[1],
+      projectName: match[2],
+    };
+  }
+
+  // フォールバック
+  return {
+    projectId: dirName,
+    projectName: dirName,
+  };
+}
+
+/**
+ * アクティブなプロジェクトを設定
+ */
+export function setActiveProject(projectPath: string): ActiveProject {
+  // 絶対パスに変換
+  const absolutePath = path.isAbsolute(projectPath)
+    ? projectPath
+    : path.resolve(process.cwd(), projectPath);
+
+  // パスの存在チェック
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Project directory not found: ${absolutePath}`);
+  }
+
+  // プロジェクトディレクトリの検証
+  if (!isValidProjectDirectory(absolutePath)) {
+    throw new Error(
+      `Invalid project directory: ${absolutePath}. ` +
+        'Expected prompts/, research/, reports/ directories and manifest.yaml'
+    );
+  }
+
+  const { projectId, projectName } = extractProjectInfo(absolutePath);
+
+  // manifest.yamlのパスを解決
+  const manifestYaml = path.join(absolutePath, 'manifest.yaml');
+  const manifestYml = path.join(absolutePath, 'manifest.yml');
+  const manifestPath = fs.existsSync(manifestYaml) ? manifestYaml : manifestYml;
+
+  currentProject = {
+    projectPath: absolutePath,
+    projectId,
+    projectName,
+    promptsDir: path.join(absolutePath, 'prompts'),
+    researchDir: path.join(absolutePath, 'research'),
+    reportsDir: path.join(absolutePath, 'reports'),
+    manifestPath,
+  };
+
+  return currentProject;
+}
+
+/**
+ * 現在のアクティブなプロジェクトを取得
+ */
+export function getActiveProject(): ActiveProject | null {
+  return currentProject;
+}
+
+/**
+ * プロジェクトがアクティブかどうか確認
+ */
+export function hasActiveProject(): boolean {
+  return currentProject !== null;
+}
+
+/**
+ * アクティブなプロジェクトをクリア
+ */
+export function clearActiveProject(): void {
+  currentProject = null;
+}
+
+/**
+ * プロジェクトの特定ディレクトリパスを取得
+ */
+export function getProjectSubdirectory(
+  subdir: 'prompts' | 'research' | 'reports'
+): string {
+  if (!currentProject) {
+    throw new Error('No active project. Use set_project tool first.');
+  }
+
+  switch (subdir) {
+    case 'prompts':
+      return currentProject.promptsDir;
+    case 'research':
+      return currentProject.researchDir;
+    case 'reports':
+      return currentProject.reportsDir;
+  }
+}
+
+/**
+ * プロジェクト情報をJSON形式で返す（MCPレスポンス用）
+ */
+export function getProjectInfo(): Record<string, unknown> {
+  if (!currentProject) {
+    return {
+      active: false,
+      message: 'No active project. Use set_project tool to set one.',
+    };
+  }
+
+  return {
+    active: true,
+    projectId: currentProject.projectId,
+    projectName: currentProject.projectName,
+    projectPath: currentProject.projectPath,
+    directories: {
+      prompts: currentProject.promptsDir,
+      research: currentProject.researchDir,
+      reports: currentProject.reportsDir,
+    },
+    manifestPath: currentProject.manifestPath,
+  };
+}
+
+/**
+ * projects/ディレクトリから最新のプロジェクトを自動検出
+ */
+export function detectLatestProject(basePath?: string): string | null {
+  const searchPath = basePath || process.cwd();
+  const projectsDir = path.join(searchPath, 'projects');
+
+  if (!fs.existsSync(projectsDir)) {
+    return null;
+  }
+
+  try {
+    const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+    const projects = entries
+      .filter((e) => e.isDirectory() && e.name.startsWith('pj'))
+      .map((e) => ({
+        name: e.name,
+        path: path.join(projectsDir, e.name),
+        mtime: fs.statSync(path.join(projectsDir, e.name)).mtime,
+      }))
+      .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+
+    if (projects.length > 0) {
+      return projects[0].path;
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  return null;
+}

package/mcp-server/src/tools/save.ts

@@ -0,0 +1,297 @@
+/**
+ * File Save Module
+ * v1.23.0 - REQ-SHIKIGAMI-016: プロンプト・検索結果の永続化
+ *
+ * プロンプトをprompts/に、検索結果をresearch/に保存する機能
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { getActiveProject, hasActiveProject } from './project.js';
+
+// 保存結果の型定義
+export interface SaveResult {
+  success: boolean;
+  filePath: string;
+  message: string;
+  timestamp: string;
+}
+
+// プロンプト保存オプション
+export interface SavePromptOptions {
+  filename?: string;
+  type: 'original' | 'structured' | 'refinement';
+  version?: number;
+  metadata?: Record<string, unknown>;
+}
+
+// リサーチ保存オプション
+export interface SaveResearchOptions {
+  filename?: string;
+  query?: string;
+  source?: 'search' | 'visit' | 'manual';
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * 現在のタイムスタンプを取得
+ */
+function getTimestamp(): string {
+  return new Date().toISOString();
+}
+
+/**
+ * 日付文字列を取得（ファイル名用）
+ */
+function getDateString(): string {
+  return new Date().toISOString().split('T')[0].replace(/-/g, '');
+}
+
+/**
+ * 時刻文字列を取得（ファイル名用）
+ */
+function getTimeString(): string {
+  return new Date().toISOString().split('T')[1].split('.')[0].replace(/:/g, '');
+}
+
+/**
+ * ファイル名をサニタイズ
+ */
+function sanitizeFilename(name: string): string {
+  return name
+    .replace(/[<>:"/\\|?*]/g, '_')
+    .replace(/\s+/g, '-')
+    .slice(0, 100);
+}
+
+/**
+ * プロンプトを保存
+ */
+export async function savePrompt(
+  content: string,
+  options: SavePromptOptions
+): Promise<SaveResult> {
+  if (!hasActiveProject()) {
+    throw new Error('No active project. Use set_project tool first.');
+  }
+
+  const project = getActiveProject()!;
+  const timestamp = getTimestamp();
+  const dateStr = getDateString();
+  const timeStr = getTimeString();
+
+  // ファイル名を決定
+  let filename: string;
+  if (options.filename) {
+    filename = sanitizeFilename(options.filename);
+  } else {
+    switch (options.type) {
+      case 'original':
+        filename = `original-prompt_${dateStr}_${timeStr}.md`;
+        break;
+      case 'structured':
+        filename = `structured-prompt_${dateStr}_${timeStr}.md`;
+        break;
+      case 'refinement':
+        filename = `refinement-${options.version || 1}_${dateStr}_${timeStr}.md`;
+        break;
+      default:
+        filename = `prompt_${dateStr}_${timeStr}.md`;
+    }
+  }
+
+  // Markdownフロントマター付きのコンテンツを生成
+  const frontmatter = {
+    timestamp,
+    project_id: project.projectId,
+    type: options.type,
+    ...(options.version && { version: options.version }),
+    ...(options.metadata && { metadata: options.metadata }),
+  };
+
+  const fullContent = `---
+timestamp: "${frontmatter.timestamp}"
+project_id: "${frontmatter.project_id}"
+type: "${frontmatter.type}"${frontmatter.version ? `\nversion: ${frontmatter.version}` : ''}
+---
+
+${content}
+`;
+
+  const filePath = path.join(project.promptsDir, filename);
+
+  try {
+    fs.writeFileSync(filePath, fullContent, 'utf-8');
+    return {
+      success: true,
+      filePath,
+      message: `Prompt saved successfully to ${filePath}`,
+      timestamp,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to save prompt: ${message}`);
+  }
+}
+
+/**
+ * 検索結果を保存
+ */
+export async function saveResearch(
+  content: string,
+  options: SaveResearchOptions
+): Promise<SaveResult> {
+  if (!hasActiveProject()) {
+    throw new Error('No active project. Use set_project tool first.');
+  }
+
+  const project = getActiveProject()!;
+  const timestamp = getTimestamp();
+  const dateStr = getDateString();
+  const timeStr = getTimeString();
+
+  // ファイル名を決定
+  let filename: string;
+  if (options.filename) {
+    filename = sanitizeFilename(options.filename);
+  } else {
+    const source = options.source || 'manual';
+    const queryPart = options.query
+      ? `_${sanitizeFilename(options.query).slice(0, 30)}`
+      : '';
+    filename = `${source}${queryPart}_${dateStr}_${timeStr}.md`;
+  }
+
+  // Markdownフロントマター付きのコンテンツを生成
+  const frontmatter = {
+    timestamp,
+    project_id: project.projectId,
+    source: options.source || 'manual',
+    ...(options.query && { query: options.query }),
+    ...(options.metadata && { metadata: options.metadata }),
+  };
+
+  const fullContent = `---
+timestamp: "${frontmatter.timestamp}"
+project_id: "${frontmatter.project_id}"
+source: "${frontmatter.source}"${frontmatter.query ? `\nquery: "${frontmatter.query}"` : ''}
+---
+
+${content}
+`;
+
+  const filePath = path.join(project.researchDir, filename);
+
+  try {
+    fs.writeFileSync(filePath, fullContent, 'utf-8');
+    return {
+      success: true,
+      filePath,
+      message: `Research saved successfully to ${filePath}`,
+      timestamp,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to save research: ${message}`);
+  }
+}
+
+/**
+ * 検索結果をJSON形式で保存
+ */
+export async function saveResearchJson(
+  data: unknown,
+  options: SaveResearchOptions
+): Promise<SaveResult> {
+  if (!hasActiveProject()) {
+    throw new Error('No active project. Use set_project tool first.');
+  }
+
+  const project = getActiveProject()!;
+  const timestamp = getTimestamp();
+  const dateStr = getDateString();
+  const timeStr = getTimeString();
+
+  // ファイル名を決定
+  let filename: string;
+  if (options.filename) {
+    filename = sanitizeFilename(options.filename);
+    if (!filename.endsWith('.json')) {
+      filename += '.json';
+    }
+  } else {
+    const source = options.source || 'manual';
+    const queryPart = options.query
+      ? `_${sanitizeFilename(options.query).slice(0, 30)}`
+      : '';
+    filename = `${source}${queryPart}_${dateStr}_${timeStr}.json`;
+  }
+
+  const jsonContent = {
+    timestamp,
+    project_id: project.projectId,
+    source: options.source || 'manual',
+    ...(options.query && { query: options.query }),
+    ...(options.metadata && { metadata: options.metadata }),
+    data,
+  };
+
+  const filePath = path.join(project.researchDir, filename);
+
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(jsonContent, null, 2), 'utf-8');
+    return {
+      success: true,
+      filePath,
+      message: `Research JSON saved successfully to ${filePath}`,
+      timestamp,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to save research JSON: ${message}`);
+  }
+}
+
+/**
+ * 汎用ファイル保存（指定ディレクトリに保存）
+ */
+export async function saveToProject(
+  content: string,
+  subdir: 'prompts' | 'research' | 'reports',
+  filename: string
+): Promise<SaveResult> {
+  if (!hasActiveProject()) {
+    throw new Error('No active project. Use set_project tool first.');
+  }
+
+  const project = getActiveProject()!;
+  const timestamp = getTimestamp();
+
+  let targetDir: string;
+  switch (subdir) {
+    case 'prompts':
+      targetDir = project.promptsDir;
+      break;
+    case 'research':
+      targetDir = project.researchDir;
+      break;
+    case 'reports':
+      targetDir = project.reportsDir;
+      break;
+  }
+
+  const filePath = path.join(targetDir, sanitizeFilename(filename));
+
+  try {
+    fs.writeFileSync(filePath, content, 'utf-8');
+    return {
+      success: true,
+      filePath,
+      message: `File saved successfully to ${filePath}`,
+      timestamp,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to save file: ${message}`);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nahisaho/shikigami",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "description": "GitHub Copilot Agent Skills for Deep Research & Consulting - AI-Powered Research Assistant with 50+ Consulting Frameworks",
   "keywords": [
     "github-copilot",

package/scripts/cli.js

@@ -31,6 +31,7 @@ Usage: npx shikigami [command] [options]
 
 Commands:
   init                    Initialize SHIKIGAMI files in current directory
+  upgrade, update         Upgrade SHIKIGAMI files (same as init --force) (v1.23.0)
   new [name]              Create a new research project
   find-related [keyword]  Find related projects by keywords (v1.7.0)
   inherit [options]       Prepare knowledge inheritance from past reports (v1.8.0)
@@ -39,6 +40,7 @@ Commands:
 
 Examples:
   npx shikigami init                           # Initialize SHIKIGAMI
+  npx shikigami upgrade                        # Upgrade to latest version
   npx shikigami new my-research                # Create new project "my-research"
   npx shikigami new                            # Create new project with auto-numbered name
   npx shikigami find-related レアアース         # Find projects related to "レアアース"
@@ -58,6 +60,14 @@ if (command === 'init') {
   process.exit(0);
 }
 
+// Upgrade/Update command (v1.23.0) - same as init --force
+if (command === 'upgrade' || command === 'update') {
+  // Inject --force flag for init.js
+  process.argv.push('--force');
+  require('./init.js');
+  process.exit(0);
+}
+
 // New project command
 if (command === 'new') {
   const projectName = args[1];
@@ -79,7 +89,7 @@ if (command === 'inherit') {
 }
 
 // Unknown command
-if (command !== 'find-related' && command !== 'inherit') {
+if (command !== 'find-related' && command !== 'inherit' && command !== 'upgrade' && command !== 'update') {
   console.error(`Unknown command: ${command}`);
   console.log('Run "npx shikigami --help" for usage information.');
   process.exit(1);