@nahisaho/shikigami 1.22.0 → 1.24.0

package/.github/prompts/shikigami-full-research.prompt.md

@@ -21,11 +21,14 @@ tools: ['shikigami-planner', 'shikigami-deep-research', 'shikigami-consulting-fr
 > **searchツール使用前に `npx shikigami new <ProjectName>` 必須**
 
 ```
-1. プロジェクト名をユーザーに質問
-2. npx shikigami new <ProjectName> 実行
-3. フォルダ作成確認後、ワークフロー開始
+1. プロジェクト名をユーザーに提案して確認
+2. ⭐ ユーザーの承認を待つ（この時点で何も実行しない）⭐
+3. 承認後に npx shikigami new <ProjectName> 実行
+4. フォルダ作成確認後、ワークフロー開始
 ```
 
+❌ **禁止**: 「確認いただく前に作成しておきます」など承認前の実行
+
 ---
 
 ## ワークフロー（5フェーズ）

package/.github/skills/configs/auto-invoke-triggers.yaml

@@ -96,6 +96,23 @@ project_initialization:
   
   invoke_at: "workflow_start"
   
+  # v1.24.0: 承認待機ルール
+  user_confirmation:
+    required: true
+    wait_for_approval: true
+    prohibited_patterns:
+      - "確認いただく前に作成"
+      - "確認前に実行"
+      - "先に作成しておきます"
+    approval_keywords:
+      - "はい"
+      - "OK"
+      - "ok"
+      - "承認"
+      - "approve"
+      - "それで"
+      - "お願いします"
+  
   required_actions:
     - action: "run_command"
       command: "npx shikigami new <ProjectName>"

package/.github/skills/shikigami-planner/SKILL.md

@@ -17,12 +17,37 @@ license: MIT
 
 **リサーチ開始前に `npx shikigami new <ProjectName>` を必ず実行。**
 - ❌ 禁止: 依頼を受けてすぐWeb検索
-- ✅ 正解: まずプロジェクト名を質問 → CLI実行
+- ❌ 禁止: プロジェクト名確認前にフォルダ作成
+- ✅ 正解: まずプロジェクト名を質問 → **ユーザーの承認を待つ** → CLI実行
 
 ---
 
 ## Phase 0: プロジェクト初期化
 
+### ⚠️ 必須フロー（v1.24.0）
+
+```
+1. プロジェクト名を提案してユーザーに確認
+2. ユーザーが「はい」「OK」「承認」等で同意するまで待機
+3. 承認後に npx shikigami new <ProjectName> を実行
+4. フォルダ作成確認後、ワークフロー開始
+```
+
+❌ **禁止パターン**:
+```
+「プロジェクト名はXXXでよろしいでしょうか？」
+「確認いただく前に、プロジェクトを作成しておきます」  ← これは禁止！
+```
+
+✅ **正しいパターン**:
+```
+「プロジェクト名はXXXでよろしいでしょうか？」
+→ ユーザーの返答を待つ（何も実行しない）
+→ ユーザーが承認したら npx shikigami new XXX を実行
+```
+
+### コマンド
+
 ```bash
 npx shikigami new <ProjectName>  # 英数字CamelCase、ハイフン禁止
 ```

package/CHANGELOG.md

@@ -5,6 +5,79 @@ 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.24.0] - 2026-01-27
+
+### Fixed
+
+- **プロジェクト名確認前にフォルダが作成される問題を修正**
+  - 問題: 「プロジェクト名はXXXでよろしいでしょうか？」の後、承認を待たずにフォルダを作成していた
+  - 原因: SKILL.mdとプロンプトに「承認を待つ」指示が不足していた
+  - 対策: Phase 0のフローに「ユーザー承認待機」ステップを追加
+
+### Changed
+
+- **shikigami-planner/SKILL.md**
+  - Phase 0に「必須フロー」セクションを追加
+  - 禁止パターンと正しいパターンを明記
+  - 「確認いただく前に作成しておきます」を禁止パターンとして明示
+
+- **shikigami-full-research.prompt.md**
+  - 最重要ルールに「ユーザーの承認を待つ」ステップを追加
+  - 禁止行動を明示
+
+- **auto-invoke-triggers.yaml**
+  - `user_confirmation` セクションを追加
+  - `wait_for_approval: true` で承認待機を強制
+  - `prohibited_patterns` で禁止パターンを定義
+  - `approval_keywords` で承認キーワードを定義
+
+---
+
+## [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');
+    });
+  });
+});