zettelkasten-starter 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Enokisan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# 私のZettelkasten
+
+Zettelkastenメソッドを使った知識管理システムへようこそ!
+
+## 📁 ディレクトリ構造
+
+このプロジェクトは4つの基本的なノートタイプで構成されています:
+
+### 01_FleetingNote（フリーティングノート）
+
+- 瞬間的なアイデアや思いつき
+- 後で整理するための一時的なメモ
+- 短時間で記録する簡潔なノート
+
+### 02_LiteratureNote（文献ノート）
+
+- 本、記事、動画などの内容要約
+- 引用や参考文献の記録
+- 自分の言葉での解釈や感想
+
+### 03_PermanentNote（パーマネントノート）
+
+- 完全に自分の言葉で表現された知識
+- 他のノートと関連付けられた洞察
+- 長期的に価値のある知見
+
+### 04_StructureNote（構造ノート）
+
+- テーマやトピックの概要
+- 関連するノートへのインデックス
+- 知識の地図やナビゲーション
+
+## 💡 使い方のコツ
+
+1. **小さく始める**: まずはFleetingNoteに思いついたことを書く
+2. **定期的な整理**: FleetingNoteを他のノートタイプに昇格させる
+3. **リンクを作る**: `[[ノート名]]`で他のノートと関連付ける
+4. **継続が重要**: 毎日少しずつでも続ける
+
+## 📝 ファイル命名規則
+
+- 日付ベース: `YYYY-MM-DD_タイトル.md`
+- ID ベース: `001_タイトル.md`
+- 自由形式: `意味のあるタイトル.md`
+
+あなたに合った方法を選んでください！
+
+## 🚀 さあ、始めましょう！
+
+各ディレクトリにサンプルファイルが用意されています。
+それらを参考に、あなた独自のZettelkastenを構築していってください。
+
+---
+
+**Happy Note-Taking! 📚✨**

package/__tests__/cli.test.js

@@ -0,0 +1,217 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { spawn } = require('child_process');
+
+// テスト用の一時ディレクトリ
+const testDir = path.join(__dirname, 'cli-test-output');
+
+describe('CLI Tool', () => {
+  beforeEach(async () => {
+    // 各テスト前にクリーンな状態にする
+    await fs.remove(testDir);
+    await fs.ensureDir(testDir);
+  });
+
+  afterEach(async () => {
+    // 各テスト後にクリーンアップ
+    await fs.remove(testDir);
+  });
+
+  const runCLI = (args = [], input = '') => {
+    return new Promise((resolve, reject) => {
+      const cliPath = path.join(__dirname, '../bin/create-zettelkasten.js');
+      const child = spawn('node', [cliPath, ...args], {
+        cwd: testDir,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        resolve({ code, stdout, stderr });
+      });
+
+      child.on('error', (err) => {
+        reject(err);
+      });
+
+      if (input) {
+        child.stdin.write(input);
+        child.stdin.end();
+      }
+    });
+  };
+
+  test('プロジェクト名を引数で指定してプロジェクトが作成される', async () => {
+    const projectName = 'test-project-arg';
+    const result = await runCLI([projectName]);
+
+    expect(result.code).toBe(0);
+    expect(result.stdout).toContain('🎉 Zettelkasten project created successfully!');
+    expect(result.stdout).toContain(`📁 Location: ${path.join(testDir, projectName)}`);
+
+    // プロジェクトディレクトリが作成されているか確認
+    const projectPath = path.join(testDir, projectName);
+    expect(await fs.pathExists(projectPath)).toBe(true);
+    
+    // 基本ディレクトリが作成されているか確認
+    expect(await fs.pathExists(path.join(projectPath, '01_FleetingNote'))).toBe(true);
+    expect(await fs.pathExists(path.join(projectPath, 'README.md'))).toBe(true);
+  }, 10000);
+
+  test('日本語オプションでプロジェクトが作成される', async () => {
+    const projectName = 'test-project-ja';
+    const result = await runCLI([projectName, '--lang', 'ja']);
+
+    expect(result.code).toBe(0);
+    expect(result.stdout).toContain('🎉 Zettelkasten project created successfully!');
+
+    // 日本語のREADMEが作成されているか確認
+    const readmePath = path.join(testDir, projectName, 'README.md');
+    const readmeContent = await fs.readFile(readmePath, 'utf8');
+    expect(readmeContent).toContain('私のZettelkasten');
+  }, 10000);
+
+  test('-lフラグでも言語指定ができる', async () => {
+    const projectName = 'test-project-l-flag';
+    const result = await runCLI([projectName, '-l', 'ja']);
+
+    expect(result.code).toBe(0);
+    
+    const readmePath = path.join(testDir, projectName, 'README.md');
+    const readmeContent = await fs.readFile(readmePath, 'utf8');
+    expect(readmeContent).toContain('私のZettelkasten');
+  }, 10000);
+
+  test('バージョン情報が表示される', async () => {
+    const result = await runCLI(['--version']);
+    
+    expect(result.code).toBe(0);
+    expect(result.stdout).toContain('1.0.0');
+  });
+
+  test('ヘルプが表示される', async () => {
+    const result = await runCLI(['--help']);
+    
+    expect(result.code).toBe(0);
+    expect(result.stdout).toContain('Create a Zettelkasten project');
+    expect(result.stdout).toContain('Usage:');
+    expect(result.stdout).toContain('Options:');
+  });
+
+  test('対話モードでプロジェクト名を入力して作成される', async () => {
+    const projectName = 'interactive-project';
+    const result = await runCLI([], `${projectName}\n`);
+
+    expect(result.code).toBe(0);
+    expect(result.stdout).toContain('📝 Enter project name:');
+    expect(result.stdout).toContain('🎉 Zettelkasten project created successfully!');
+
+    // プロジェクトが作成されているか確認
+    const projectPath = path.join(testDir, projectName);
+    expect(await fs.pathExists(projectPath)).toBe(true);
+  }, 10000);
+
+  test('空のプロジェクト名で対話モードが失敗する', async () => {
+    const result = await runCLI([], '\n');
+
+    expect(result.code).toBe(1);
+    expect(result.stdout).toContain('❌ Project name cannot be empty');
+  }, 10000);
+
+  test('既存のディレクトリ名を指定しても正常に動作する', async () => {
+    const projectName = 'existing-dir';
+    const projectPath = path.join(testDir, projectName);
+    
+    // 既存のディレクトリを作成
+    await fs.ensureDir(projectPath);
+    await fs.writeFile(path.join(projectPath, 'existing.txt'), 'test');
+
+    const result = await runCLI([projectName]);
+
+    expect(result.code).toBe(0);
+    expect(result.stdout).toContain('🎉 Zettelkasten project created successfully!');
+
+    // 既存ファイルが残っているか確認
+    expect(await fs.pathExists(path.join(projectPath, 'existing.txt'))).toBe(true);
+    // 新しいディレクトリも作成されているか確認
+    expect(await fs.pathExists(path.join(projectPath, '01_FleetingNote'))).toBe(true);
+  }, 10000);
+
+  test('サポートされていない言語でもエラーにならない', async () => {
+    const projectName = 'test-unsupported-lang';
+    const result = await runCLI([projectName, '--lang', 'fr']);
+
+    expect(result.code).toBe(0);
+    expect(result.stdout).toContain('🎉 Zettelkasten project created successfully!');
+
+    // 英語のREADMEが作成されているか確認（フォールバック）
+    const readmePath = path.join(testDir, projectName, 'README.md');
+    const readmeContent = await fs.readFile(readmePath, 'utf8');
+    expect(readmeContent).toContain('My Zettelkasten');
+  }, 10000);
+
+  test('相対パスでプロジェクトが作成される', async () => {
+    const projectName = 'relative-path-project';
+    const result = await runCLI([projectName]);
+
+    expect(result.code).toBe(0);
+    
+    // カレントディレクトリ（testDir）にプロジェクトが作成されているか確認
+    const projectPath = path.join(testDir, projectName);
+    expect(await fs.pathExists(projectPath)).toBe(true);
+    expect(result.stdout).toContain(`📁 Location: ${projectPath}`);
+  }, 10000);
+
+  test('使用方法の指示が正しく表示される', async () => {
+    const projectName = 'usage-test';
+    const result = await runCLI([projectName]);
+
+    expect(result.code).toBe(0);
+    expect(result.stdout).toContain('📝 To get started:');
+    expect(result.stdout).toContain(`cd ${projectName}`);
+    expect(result.stdout).toContain('Check README.md for guidance');
+  }, 10000);
+});
+
+describe('CLIエラーハンドリング', () => {
+  test('無効なオプションでエラーが発生する', async () => {
+    const runCLI = (args = []) => {
+      return new Promise((resolve) => {
+        const cliPath = path.join(__dirname, '../bin/create-zettelkasten.js');
+        const child = spawn('node', [cliPath, ...args], {
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout.on('data', (data) => {
+          stdout += data.toString();
+        });
+
+        child.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+
+        child.on('close', (code) => {
+          resolve({ code, stdout, stderr });
+        });
+      });
+    };
+
+    const result = await runCLI(['--invalid-option']);
+    
+    expect(result.code).not.toBe(0);
+    expect(result.stderr).toContain('unknown option');
+  });
+}); 

package/__tests__/creator.test.js

@@ -0,0 +1,207 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { createZettelkasten } = require('../lib/creator');
+
+// テスト用の一時ディレクトリを管理
+const testDir = path.join(__dirname, 'test-output');
+
+describe('Zettelkasten Creator', () => {
+  beforeEach(async () => {
+    // 各テスト前にクリーンな状態にする
+    await fs.remove(testDir);
+  });
+
+  afterEach(async () => {
+    // 各テスト後にクリーンアップ
+    await fs.remove(testDir);
+  });
+
+  describe('createZettelkasten', () => {
+    test('英語版のZettelkastenプロジェクトが正常に作成される', async () => {
+      const projectPath = path.join(testDir, 'test-zettelkasten-en');
+      
+      await createZettelkasten(projectPath, 'en');
+      
+      // ディレクトリが作成されているか確認
+      expect(await fs.pathExists(projectPath)).toBe(true);
+      
+      // 基本ディレクトリが作成されているか確認
+      const expectedDirs = [
+        '01_FleetingNote',
+        '02_LiteratureNote',
+        '03_PermanentNote',
+        '04_StructureNote'
+      ];
+      
+      for (const dir of expectedDirs) {
+        const dirPath = path.join(projectPath, dir);
+        expect(await fs.pathExists(dirPath)).toBe(true);
+        expect((await fs.stat(dirPath)).isDirectory()).toBe(true);
+      }
+    });
+
+    test('日本語版のZettelkastenプロジェクトが正常に作成される', async () => {
+      const projectPath = path.join(testDir, 'test-zettelkasten-ja');
+      
+      await createZettelkasten(projectPath, 'ja');
+      
+      // ディレクトリが作成されているか確認
+      expect(await fs.pathExists(projectPath)).toBe(true);
+      
+      // README.mdが作成され、日本語コンテンツが含まれているか確認
+      const readmePath = path.join(projectPath, 'README.md');
+      expect(await fs.pathExists(readmePath)).toBe(true);
+      
+      const readmeContent = await fs.readFile(readmePath, 'utf8');
+      expect(readmeContent).toContain('私のZettelkasten');
+      expect(readmeContent).toContain('フリーティングノート');
+      expect(readmeContent).toContain('ディレクトリ構造');
+    });
+
+    test('英語版のREADMEファイルが正しく作成される', async () => {
+      const projectPath = path.join(testDir, 'test-zettelkasten-en');
+      
+      await createZettelkasten(projectPath, 'en');
+      
+      const readmePath = path.join(projectPath, 'README.md');
+      expect(await fs.pathExists(readmePath)).toBe(true);
+      
+      const readmeContent = await fs.readFile(readmePath, 'utf8');
+      expect(readmeContent).toContain('My Zettelkasten');
+      expect(readmeContent).toContain('FleetingNote');
+      expect(readmeContent).toContain('Directory Structure');
+      expect(readmeContent).toContain('Happy Note-Taking!');
+    });
+
+    test('サンプルファイルが正しく作成される', async () => {
+      const projectPath = path.join(testDir, 'test-zettelkasten-sample');
+      
+      await createZettelkasten(projectPath, 'en');
+      
+      // 各ディレクトリにサンプルファイルが作成されているか確認
+      const fleetingNotePath = path.join(projectPath, '01_FleetingNote');
+      const literatureNotePath = path.join(projectPath, '02_LiteratureNote');
+      const permanentNotePath = path.join(projectPath, '03_PermanentNote');
+      const structureNotePath = path.join(projectPath, '04_StructureNote');
+      
+      // 各ディレクトリにファイルが存在することを確認
+      const fleetingFiles = await fs.readdir(fleetingNotePath);
+      const literatureFiles = await fs.readdir(literatureNotePath);
+      const permanentFiles = await fs.readdir(permanentNotePath);
+      const structureFiles = await fs.readdir(structureNotePath);
+      
+      expect(fleetingFiles.length).toBeGreaterThan(0);
+      expect(literatureFiles.length).toBeGreaterThan(0);
+      expect(permanentFiles.length).toBeGreaterThan(0);
+      expect(structureFiles.length).toBeGreaterThan(0);
+      
+      // サンプルファイルの内容を確認
+      const sampleFleetingFile = path.join(fleetingNotePath, fleetingFiles[0]);
+      const content = await fs.readFile(sampleFleetingFile, 'utf8');
+      expect(content).toBeTruthy();
+      expect(content.length).toBeGreaterThan(0);
+    });
+
+    test('既存のディレクトリに対しても正常に動作する', async () => {
+      const projectPath = path.join(testDir, 'existing-dir');
+      
+      // 既存のディレクトリを作成
+      await fs.ensureDir(projectPath);
+      await fs.writeFile(path.join(projectPath, 'existing-file.txt'), 'existing content');
+      
+      await createZettelkasten(projectPath, 'en');
+      
+      // 既存ファイルが残っているか確認
+      expect(await fs.pathExists(path.join(projectPath, 'existing-file.txt'))).toBe(true);
+      
+      // 新しいディレクトリも作成されているか確認
+      expect(await fs.pathExists(path.join(projectPath, '01_FleetingNote'))).toBe(true);
+      expect(await fs.pathExists(path.join(projectPath, 'README.md'))).toBe(true);
+    });
+
+    test('デフォルト言語は英語である', async () => {
+      const projectPath = path.join(testDir, 'test-default-lang');
+      
+      // 言語パラメータを指定せずに呼び出し
+      await createZettelkasten(projectPath);
+      
+      const readmePath = path.join(projectPath, 'README.md');
+      const readmeContent = await fs.readFile(readmePath, 'utf8');
+      
+      // 英語のコンテンツが含まれているか確認
+      expect(readmeContent).toContain('My Zettelkasten');
+      expect(readmeContent).not.toContain('私のZettelkasten');
+    });
+
+    test('無効な言語が指定された場合は英語で作成される', async () => {
+      const projectPath = path.join(testDir, 'test-invalid-lang');
+      
+      await createZettelkasten(projectPath, 'invalid-language');
+      
+      const readmePath = path.join(projectPath, 'README.md');
+      const readmeContent = await fs.readFile(readmePath, 'utf8');
+      
+      // 英語のコンテンツが含まれているか確認
+      expect(readmeContent).toContain('My Zettelkasten');
+    });
+
+    test('空の文字列パスでエラーがスローされる', async () => {
+      await expect(createZettelkasten('')).rejects.toThrow();
+    });
+
+    test('権限がない場所への作成でエラーがスローされる', async () => {
+      // アクセス権限がない場所を指定
+      const restrictedPath = '/root/no-permission';
+      
+      await expect(createZettelkasten(restrictedPath)).rejects.toThrow();
+    });
+  });
+
+  describe('ファイル構造の検証', () => {
+    test('作成されたプロジェクトが期待される構造を持つ', async () => {
+      const projectPath = path.join(testDir, 'structure-test');
+      
+      await createZettelkasten(projectPath, 'ja');
+      
+      // ルートレベルのファイル確認
+      expect(await fs.pathExists(path.join(projectPath, 'README.md'))).toBe(true);
+      
+      // ディレクトリ構造確認
+      const expectedStructure = [
+        '01_FleetingNote',
+        '02_LiteratureNote', 
+        '03_PermanentNote',
+        '04_StructureNote'
+      ];
+      
+      for (const dir of expectedStructure) {
+        const dirPath = path.join(projectPath, dir);
+        expect(await fs.pathExists(dirPath)).toBe(true);
+        
+        // 各ディレクトリにサンプルファイルが存在することを確認
+        const files = await fs.readdir(dirPath);
+        expect(files.length).toBeGreaterThan(0);
+        
+        // 少なくとも1つのmarkdownファイルが存在することを確認
+        const markdownFiles = files.filter(file => file.endsWith('.md'));
+        expect(markdownFiles.length).toBeGreaterThan(0);
+      }
+    });
+
+    test('README.mdの内容が適切な形式である', async () => {
+      const projectPath = path.join(testDir, 'readme-test');
+      
+      await createZettelkasten(projectPath, 'ja');
+      
+      const readmePath = path.join(projectPath, 'README.md');
+      const content = await fs.readFile(readmePath, 'utf8');
+      
+      // Markdownの基本的な要素が含まれているか確認
+      expect(content).toMatch(/^#\s/m); // H1ヘッダーが存在
+      expect(content).toMatch(/^##\s/m); // H2ヘッダーが存在
+      expect(content).toMatch(/^###\s/m); // H3ヘッダーが存在
+      expect(content).toContain('`'); // コードブロックが存在
+      expect(content).toContain('📁'); // 絵文字が含まれている
+    });
+  });
+}); 

package/__tests__/integration.test.js

@@ -0,0 +1,214 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { createZettelkasten } = require('../lib/creator');
+
+// テスト用の一時ディレクトリ
+const testDir = path.join(__dirname, 'integration-test-output');
+
+describe('統合テスト', () => {
+  beforeEach(async () => {
+    await fs.remove(testDir);
+    await fs.ensureDir(testDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(testDir);
+  });
+
+  test('完全なZettelkastenプロジェクトが期待通りに機能する', async () => {
+    const projectPath = path.join(testDir, 'full-project');
+    
+    // プロジェクトを作成
+    await createZettelkasten(projectPath, 'ja');
+
+    // 1. プロジェクト構造の完全性確認
+    const expectedDirs = [
+      '01_FleetingNote',
+      '02_LiteratureNote',
+      '03_PermanentNote',
+      '04_StructureNote'
+    ];
+
+    for (const dir of expectedDirs) {
+      const dirPath = path.join(projectPath, dir);
+      expect(await fs.pathExists(dirPath)).toBe(true);
+      
+      // 各ディレクトリにサンプルファイルが存在することを確認
+      const files = await fs.readdir(dirPath);
+      expect(files.length).toBeGreaterThan(0);
+      
+      // 最初のファイルの内容を確認
+      const firstFile = files[0];
+      const filePath = path.join(dirPath, firstFile);
+      const content = await fs.readFile(filePath, 'utf8');
+      expect(content.trim().length).toBeGreaterThan(0);
+    }
+
+    // 2. README.mdの内容確認
+    const readmePath = path.join(projectPath, 'README.md');
+    expect(await fs.pathExists(readmePath)).toBe(true);
+    
+    const readmeContent = await fs.readFile(readmePath, 'utf8');
+    
+    // 必要なセクションが全て含まれているか確認
+    expect(readmeContent).toContain('私のZettelkasten');
+    expect(readmeContent).toContain('📁 ディレクトリ構造');
+    expect(readmeContent).toContain('01_FleetingNote（フリーティングノート）');
+    expect(readmeContent).toContain('02_LiteratureNote（文献ノート）');
+    expect(readmeContent).toContain('03_PermanentNote（パーマネントノート）');
+    expect(readmeContent).toContain('04_StructureNote（構造ノート）');
+    expect(readmeContent).toContain('💡 使い方のコツ');
+    expect(readmeContent).toContain('🏷️ タグの使い方');
+    expect(readmeContent).toContain('📝 ファイル命名規則');
+    expect(readmeContent).toContain('🚀 さあ、始めましょう！');
+
+    // 3. ファイル拡張子の確認
+    for (const dir of expectedDirs) {
+      const dirPath = path.join(projectPath, dir);
+      const files = await fs.readdir(dirPath);
+      
+      for (const file of files) {
+        expect(file).toMatch(/\.md$/); // 全てのファイルがMarkdown形式
+      }
+    }
+  });
+
+  test('英語と日本語のプロジェクトが共存できる', async () => {
+    const enProjectPath = path.join(testDir, 'en-project');
+    const jaProjectPath = path.join(testDir, 'ja-project');
+
+    // 英語版プロジェクト作成
+    await createZettelkasten(enProjectPath, 'en');
+    
+    // 日本語版プロジェクト作成
+    await createZettelkasten(jaProjectPath, 'ja');
+
+    // 両方のプロジェクトが存在することを確認
+    expect(await fs.pathExists(enProjectPath)).toBe(true);
+    expect(await fs.pathExists(jaProjectPath)).toBe(true);
+
+    // 英語版READMEの確認
+    const enReadme = await fs.readFile(path.join(enProjectPath, 'README.md'), 'utf8');
+    expect(enReadme).toContain('My Zettelkasten');
+    expect(enReadme).toContain('Directory Structure');
+
+    // 日本語版READMEの確認
+    const jaReadme = await fs.readFile(path.join(jaProjectPath, 'README.md'), 'utf8');
+    expect(jaReadme).toContain('私のZettelkasten');
+    expect(jaReadme).toContain('ディレクトリ構造');
+
+    // 両プロジェクトが同じディレクトリ構造を持つことを確認
+    const enDirs = await fs.readdir(enProjectPath);
+    const jaDirs = await fs.readdir(jaProjectPath);
+    
+    const expectedDirs = [
+      '01_FleetingNote',
+      '02_LiteratureNote',
+      '03_PermanentNote',
+      '04_StructureNote',
+      'README.md'
+    ];
+    
+    expectedDirs.forEach(item => {
+      expect(enDirs).toContain(item);
+      expect(jaDirs).toContain(item);
+    });
+  });
+
+  test('既存ファイルがある環境での安全な作成', async () => {
+    const projectPath = path.join(testDir, 'existing-content');
+    
+    // 既存コンテンツを作成
+    await fs.ensureDir(projectPath);
+    await fs.writeFile(path.join(projectPath, 'my-notes.md'), '# 既存のメモ\n重要な内容');
+    await fs.ensureDir(path.join(projectPath, 'custom-folder'));
+    await fs.writeFile(path.join(projectPath, 'custom-folder', 'data.txt'), 'カスタムデータ');
+
+    // Zettelkastenプロジェクトを追加
+    await createZettelkasten(projectPath, 'ja');
+
+    // 既存ファイルが保持されているか確認
+    expect(await fs.pathExists(path.join(projectPath, 'my-notes.md'))).toBe(true);
+    expect(await fs.pathExists(path.join(projectPath, 'custom-folder', 'data.txt'))).toBe(true);
+
+    const existingContent = await fs.readFile(path.join(projectPath, 'my-notes.md'), 'utf8');
+    expect(existingContent).toContain('重要な内容');
+
+    // 新しいZettelkastenディレクトリも作成されているか確認
+    expect(await fs.pathExists(path.join(projectPath, '01_FleetingNote'))).toBe(true);
+    expect(await fs.pathExists(path.join(projectPath, 'README.md'))).toBe(true);
+  });
+
+  test('サンプルファイルの品質確認', async () => {
+    const projectPath = path.join(testDir, 'sample-quality');
+    
+    await createZettelkasten(projectPath, 'ja');
+
+    const directories = [
+      '01_FleetingNote',
+      '02_LiteratureNote',
+      '03_PermanentNote',
+      '04_StructureNote'
+    ];
+
+    for (const dir of directories) {
+      const dirPath = path.join(projectPath, dir);
+      const files = await fs.readdir(dirPath);
+      
+      for (const file of files) {
+        const filePath = path.join(dirPath, file);
+        const content = await fs.readFile(filePath, 'utf8');
+        
+        // Markdownファイルの基本的な品質確認
+        expect(content).toMatch(/^#/m); // ヘッダーが存在
+        expect(content.length).toBeGreaterThan(50); // 適度な長さ
+        expect(content).toContain('\n'); // 複数行
+        
+        // 日本語のサンプルファイルであることを確認
+        expect(content).toMatch(/[ひらがなカタカナ漢字]/);
+      }
+    }
+  });
+
+  test('大量のファイル作成でもパフォーマンスが問題ない', async () => {
+    const startTime = Date.now();
+    
+    // 複数のプロジェクトを連続作成
+    const projectPromises = [];
+    for (let i = 0; i < 5; i++) {
+      const projectPath = path.join(testDir, `performance-test-${i}`);
+      projectPromises.push(createZettelkasten(projectPath, i % 2 === 0 ? 'en' : 'ja'));
+    }
+    
+    await Promise.all(projectPromises);
+    
+    const endTime = Date.now();
+    const elapsedTime = endTime - startTime;
+    
+    // 5秒以内に完了することを確認（合理的なパフォーマンス要件）
+    expect(elapsedTime).toBeLessThan(5000);
+    
+    // 全てのプロジェクトが正常に作成されたことを確認
+    for (let i = 0; i < 5; i++) {
+      const projectPath = path.join(testDir, `performance-test-${i}`);
+      expect(await fs.pathExists(projectPath)).toBe(true);
+      expect(await fs.pathExists(path.join(projectPath, 'README.md'))).toBe(true);
+    }
+  });
+
+  test('エラー発生後の状態確認', async () => {
+    const projectPath = path.join(testDir, 'error-recovery');
+    
+    // 権限のないディレクトリの親を作成してから権限を変更する代わりに
+    // 無効なパス文字を使用してエラーを発生させる
+    const invalidPath = path.join(testDir, 'invalid\x00path');
+    
+    await expect(createZettelkasten(invalidPath, 'ja')).rejects.toThrow();
+    
+    // その後正常なプロジェクト作成ができることを確認
+    await createZettelkasten(projectPath, 'ja');
+    
+    expect(await fs.pathExists(projectPath)).toBe(true);
+    expect(await fs.pathExists(path.join(projectPath, 'README.md'))).toBe(true);
+  });
+}); 

package/bin/create-zettelkasten.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const path = require('path');
+const readline = require('readline');
+const { createZettelkasten } = require('../lib/creator');
+
+/**
+ * 対話的にプロジェクト名を取得
+ */
+function askProjectName() {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question('📝 Enter project name: ', (answer) => {
+      rl.close();
+      const projectName = answer.trim();
+      if (projectName === '') {
+        console.log('❌ Project name cannot be empty. Please try again.');
+        process.exit(1);
+      }
+      resolve(projectName);
+    });
+  });
+}
+
+program
+  .version('1.0.0')
+  .argument('[project-name]', 'Project name (optional - will prompt if not provided)')
+  .option('-l, --lang <language>', 'Generation language (en|ja)', 'en')
+  .description('Create a Zettelkasten project')
+  .action(async (projectName, options) => {
+    try {
+      // プロジェクト名が提供されていない場合は対話モードで取得
+      if (!projectName) {
+        projectName = await askProjectName();
+      }
+      
+      const targetPath = path.resolve(process.cwd(), projectName);
+      await createZettelkasten(targetPath, options.lang);
+      
+      console.log('🎉 Zettelkasten project created successfully!');
+      console.log(`📁 Location: ${targetPath}`);
+      console.log(`\n📝 To get started:`);
+      console.log(`   cd ${projectName}`);
+      console.log(`   Check README.md for guidance`);
+    } catch (error) {
+      console.error('❌ Error occurred:', error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse(); 

package/index.js

@@ -0,0 +1,5 @@
+const { createZettelkasten } = require('./lib/creator');
+
+module.exports = {
+  createZettelkasten
+}; 

package/lib/creator.js

@@ -0,0 +1,553 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Zettelkastenプロジェクトを作成する
+ * @param {string} targetPath - 作成先のパス
+ * @param {string} language - 言語 ('en' | 'ja')
+ */
+async function createZettelkasten(targetPath, language = 'en') {
+  // ディレクトリが存在しない場合は作成
+  await fs.ensureDir(targetPath);
+  
+  // 4つの基本ディレクトリを作成
+  const directories = [
+    '01_FleetingNote',
+    '02_LiteratureNote', 
+    '03_PermanentNote',
+    '04_StructureNote'
+  ];
+  
+  for (const dir of directories) {
+    await fs.ensureDir(path.join(targetPath, dir));
+  }
+  
+  // README.mdを作成
+  const readmeContent = getReadmeContent(language);
+  await fs.writeFile(path.join(targetPath, 'README.md'), readmeContent);
+  
+  // サンプルファイルを作成
+  await createSampleFiles(targetPath, language);
+}
+
+/**
+ * 言語に応じたREADMEコンテンツを取得
+ * @param {string} language - 言語
+ * @returns {string} READMEの内容
+ */
+function getReadmeContent(language) {
+  if (language === 'ja') {
+    return `# 私のZettelkasten
+
+Zettelkastenメソッドを使った知識管理システムへようこそ!
+
+## 📁 ディレクトリ構造
+
+このプロジェクトは4つの基本的なノートタイプで構成されています:
+
+### 01_FleetingNote（フリーティングノート）
+
+- 瞬間的なアイデアや思いつき
+- 後で整理するための一時的なメモ
+- 短時間で記録する簡潔なノート
+
+### 02_LiteratureNote（文献ノート）
+
+- 本、記事、動画などの内容要約
+- 引用や参考文献の記録
+- 自分の言葉での解釈や感想
+
+### 03_PermanentNote（パーマネントノート）
+
+- 完全に自分の言葉で表現された知識
+- 他のノートと関連付けられた洞察
+- 長期的に価値のある知見
+
+### 04_StructureNote（構造ノート）
+
+- テーマやトピックの概要
+- 関連するノートへのインデックス
+- 知識の地図やナビゲーション
+
+## 💡 使い方のコツ
+
+1. **小さく始める**: まずはFleetingNoteに思いついたことを書く
+2. **定期的な整理**: FleetingNoteを他のノートタイプに昇格させる
+3. **リンクを作る**: \`[[ノート名]]\`で他のノートと関連付ける
+4. **タグを活用**: \`#concept\` \`#method\` \`#review\`などでカテゴライズ
+5. **継続が重要**: 毎日少しずつでも続ける
+
+## 🏷️ タグの使い方
+
+タグは情報の分類と検索を効率化します：
+
+- \`#concept\` - 概念や理論
+- \`#method\` - 方法論やテクニック  
+- \`#review\` - 振り返りや評価
+- \`#source/book\` - 書籍からの情報
+- \`#source/article\` - 記事からの情報
+- \`#draft\` - 下書きや未完成
+- \`#important\` - 重要度の高い内容
+- \`#todo\` - アクションアイテム
+- \`#気の赴くままに\` - 好きなタグを追加していきましょう
+
+## 📝 ファイル命名規則
+
+- 日付ベース: \`YYYY-MM-DD_タイトル.md\`
+- ID ベース: \`001_タイトル.md\`
+- 自由形式: \`意味のあるタイトル.md\`
+
+あなたに合った方法を選んでください！
+
+## 🚀 さあ、始めましょう！
+
+各ディレクトリにサンプルファイルが用意されています。
+それらを参考に、あなた独自のZettelkastenを構築していってください。
+
+---
+
+**Happy Note-Taking! 📚✨**
+`;
+  } else {
+    return `# My Zettelkasten
+
+Welcome to your knowledge management system using the Zettelkasten method!
+
+## 📁 Directory Structure
+
+This project consists of four basic note types:
+
+### 01_FleetingNote
+
+- Fleeting ideas and quick thoughts
+- Temporary notes for later organization
+- Brief notes recorded in a short time
+
+### 02_LiteratureNote
+
+- Summaries of books, articles, videos, etc.
+- Citations and references
+- Your interpretations and reflections
+
+### 03_PermanentNote
+
+- Knowledge expressed entirely in your own words
+- Insights linked to other notes
+- Long-term valuable insights
+
+### 04_StructureNote
+
+- Overview of themes and topics
+- Index to related notes
+- Knowledge maps and navigation
+
+## 💡 Tips for Usage
+
+1. **Start small**: First write down your thoughts in FleetingNote
+2. **Regular organization**: Promote FleetingNotes to other note types
+3. **Create links**: Use \`[[Note Name]]\` to connect with other notes
+4. **Use tags**: Categorize with \`#concept\` \`#method\` \`#review\` etc.
+5. **Consistency is key**: Continue a little bit every day
+
+## 🏷️ How to Use Tags
+
+Tags help organize and search information efficiently:
+
+- \`#concept\` - Concepts and theories
+- \`#method\` - Methodologies and techniques
+- \`#review\` - Reflections and evaluations
+- \`#source/book\` - Information from books
+- \`#source/article\` - Information from articles
+- \`#draft\` - Drafts and work in progress
+- \`#important\` - High priority content
+- \`#todo\` - Action items
+- \`#asyouwish\` - Add your own tags as you go
+
+## 📝 File Naming Conventions
+
+- Date-based: \`YYYY-MM-DD_title.md\`
+- ID-based: \`001_title.md\`
+- Free-form: \`meaningful-title.md\`
+
+Choose the method that works best for you!
+
+## 🚀 Let's Get Started!
+
+Sample files are prepared in each directory.
+Use them as references to build your unique Zettelkasten.
+
+---
+
+**Happy Note-Taking! 📚✨**
+`;
+  }
+}
+
+/**
+ * サンプルファイルを作成
+ * @param {string} targetPath - 作成先のパス
+ * @param {string} language - 言語
+ */
+async function createSampleFiles(targetPath, language) {
+  const samples = getSampleContents(language);
+  
+  for (const [filePath, content] of Object.entries(samples)) {
+    await fs.writeFile(path.join(targetPath, filePath), content);
+  }
+}
+
+/**
+ * サンプルファイルの内容を取得
+ * @param {string} language - 言語
+ * @returns {Object} ファイルパスとコンテンツのオブジェクト
+ */
+function getSampleContents(language) {
+  if (language === 'ja') {
+    return {
+      '01_FleetingNote/sample_fleeting.md': `# フリーティングノートのサンプル
+
+日付: ${new Date().toISOString().split('T')[0]}
+タグ: #fleeting #zettelkasten #idea #draft
+
+## 💭 今日の思いつき
+
+- Zettelkastenを始めてみた
+- アイデアを素早くキャッチするのが重要
+- 後で整理することを前提に、まずは記録
+
+## 🔗 関連する可能性
+
+- [[学習方法について]]
+- [[知識管理システム]]
+
+## 📋 次のアクション
+
+- [ ] このアイデアをより詳しく調べる #todo
+- [ ] 関連する文献を探す #todo
+
+---
+
+*これはサンプルファイルです。自由に編集・削除してください。*
+`,
+      '02_LiteratureNote/sample_literature.md': `# 文献ノートのサンプル
+
+タグ: #literature #source/book #zettelkasten #method #notes
+
+## 📚 書籍情報
+
+- **タイトル**: How to Take Smart Notes
+- **著者**: Sönke Ahrens
+- **出版年**: 2017
+- **読了日**: ${new Date().toISOString().split('T')[0]}
+
+## 📝 主要ポイント
+
+### Zettelkastenの原則
+
+1. **一つのアイデア、一つのノート**
+   - 各ノートは単一のアイデアに焦点を当てる
+   - 複雑な概念は複数のノートに分割
+
+2. **自分の言葉で書く**
+   - 単なるコピペではなく、理解した内容を表現
+   - 後で読み返した時に理解できるように
+
+3. **リンクを作る**
+   - ノート間の関連性を明示的に作る
+   - 新しい洞察が生まれる可能性
+
+## 🤔 私の考察
+
+Zettelkastenは単なるノート取りツールではなく、思考のツールだと感じた。
+重要なのは... #concept #important
+
+## 💡 アクションアイテム
+
+- [ ] 実際にZettelkastenシステムを1週間試してみる #todo
+- [ ] 効果を測定する方法を考える #todo
+
+## 🔗 関連ノート
+
+- [[001_zettelkasten_principles]]
+- [[note_taking_methods]]
+
+---
+
+*これはサンプルファイルです。実際の読書ノートに置き換えてください。*
+`,
+      '03_PermanentNote/sample_permanent.md': `# パーマネントノートのサンプル
+
+ID: 001
+作成日: ${new Date().toISOString().split('T')[0]}
+タグ: #permanent #concept #knowledge-management #connection #important
+
+## 🎯 知識管理における「つながり」の重要性
+
+知識管理システムで最も重要なのは、個々の情報ではなく、それらの**つながり**である。
+
+### なぜつながりが重要なのか
+
+1. **新しい洞察の創出**
+   - 異なる分野の知識が結びつくことで、予期しない発見が生まれる
+   - 創造性は既存要素の新しい組み合わせから生まれる
+
+2. **理解の深化**
+   - 関連する概念と結びつけることで、個別の知識がより深く理解される
+   - 文脈の中で知識を捉えることができる
+
+3. **記憶の強化**
+   - 関連付けられた情報は、単独の情報よりも記憶に残りやすい
+   - 想起の手がかりが増える
+
+### 実践的な方法
+
+- 新しいノートを作成する際は、既存の3つ以上のノートとの関連を考える
+- 定期的にノート間のリンクを見直し、新しいつながりを発見する
+- 構造ノートを使って、テーマごとの知識の地図を作る
+
+## 🔗 関連するノート
+
+- [[creativity_and_connection]]
+- [[memory_techniques]]
+- [[zettelkasten_principles]]
+
+## 📚 参考文献
+
+- Ahrens, S. (2017). How to Take Smart Notes
+- [[literature_note_smart_notes]]
+
+---
+
+*これは完全に自分の言葉で表現された知識です。*
+`,
+      '04_StructureNote/sample_structure.md': `# 構造ノート: Zettelkastenとは
+
+作成日: ${new Date().toISOString().split('T')[0]}
+タグ: #structure #zettelkasten #index #map #overview
+
+## 🗺️ このトピックの概要
+
+このノートは「Zettelkasten」というテーマの入り口として機能します。
+関連するすべてのノートへのナビゲーションを提供します。
+
+## 📖 基本概念
+
+### Zettelkastenの原則
+
+- [[001_zettelkasten_principles]] - 基本的な考え方
+- [[connection_importance]] - つながりの重要性
+- [[atomic_notes]] - アトミックノートの概念
+
+### 実践方法
+
+- [[daily_note_routine]] - 日々のノート習慣
+- [[note_linking_strategies]] - リンク戦略
+- [[review_process]] - 定期的な見直し
+
+## 📚 参考文献とソース
+
+### 文献ノート
+- [[literature_note_smart_notes]] - "How to Take Smart Notes"
+- [[literature_note_second_brain]] - "Building a Second Brain"
+
+### フリーティングノート
+- [[fleeting_zettelkasten_discovery]] - Zettelkasten発見時の印象
+- [[fleeting_digital_vs_analog]] - デジタル vs アナログの考察
+
+## 🔍 関連トピック
+
+- [[knowledge_management]] - より広い知識管理の文脈
+- [[creative_thinking]] - 創造的思考との関連
+- [[learning_systems]] - 学習システム全般
+
+## 📊 進捗状況
+
+- ✅ 基本概念の理解
+- 🔄 実践方法の模索中
+- ⭕ 自分なりのシステム構築（今後の課題）
+
+---
+
+*この構造ノートは定期的に更新し、新しいノートが追加されたら関連付けを行います。*
+`
+    };
+  } else {
+    return {
+      '01_FleetingNote/sample_fleeting.md': `# Fleeting Note Sample
+
+Date: ${new Date().toISOString().split('T')[0]}
+Tags: #fleeting #zettelkasten #idea #draft
+
+## 💭 Today's Ideas
+
+- Started using Zettelkasten
+- Quick capture of ideas is crucial
+- Focus on recording first, organizing later
+
+## 🔗 Potential Connections
+
+- [[learning_methods]]
+- [[knowledge_management_systems]]
+
+## 📋 Next Actions
+
+- [ ] Research this idea further #todo
+- [ ] Find related literature #todo
+
+---
+
+*This is a sample file. Feel free to edit or delete.*
+`,
+      '02_LiteratureNote/sample_literature.md': `# Literature Note Sample
+
+Tags: #literature #source/book #zettelkasten #method #notes
+
+## 📚 Book Information
+
+- **Title**: How to Take Smart Notes
+- **Author**: Sönke Ahrens
+- **Year**: 2017
+- **Date Read**: ${new Date().toISOString().split('T')[0]}
+
+## 📝 Key Points
+
+### Zettelkasten Principles
+
+1. **One Idea, One Note**
+   - Each note focuses on a single idea
+   - Complex concepts are split into multiple notes
+
+2. **Write in Your Own Words**
+   - Not just copy-paste, but express understanding
+   - Make it understandable when revisiting later
+
+3. **Create Links**
+   - Explicitly create relationships between notes
+   - Enables emergence of new insights
+
+## 🤔 My Reflections
+
+I realized that Zettelkasten is not just a note-taking tool, but a thinking tool.
+The important thing is... #concept #important
+
+## 💡 Action Items
+
+- [ ] Try the Zettelkasten system for a week #todo
+- [ ] Think about how to measure effectiveness #todo
+
+## 🔗 Related Notes
+
+- [[001_zettelkasten_principles]]
+- [[note_taking_methods]]
+
+---
+
+*This is a sample file. Replace with your actual reading notes.*
+`,
+      '03_PermanentNote/sample_permanent.md': `# Permanent Note Sample
+
+ID: 001
+Created: ${new Date().toISOString().split('T')[0]}
+Tags: #permanent #concept #knowledge-management #connection #important
+
+## 🎯 The Importance of "Connections" in Knowledge Management
+
+The most important aspect of knowledge management systems is not individual pieces of information, but their **connections**.
+
+### Why Connections Matter
+
+1. **Creation of New Insights**
+
+   - Unexpected discoveries emerge when knowledge from different fields connects
+   - Creativity comes from new combinations of existing elements
+
+2. **Deepening Understanding**
+
+   - Knowledge becomes more deeply understood when connected to related concepts
+   - Enables understanding knowledge within context
+
+3. **Memory Enhancement**
+
+   - Connected information is more memorable than isolated information
+   - Increases retrieval cues
+
+### Practical Methods
+
+- When creating new notes, consider connections to at least 3 existing notes
+- Regularly review links between notes to discover new connections
+- Use structure notes to create knowledge maps by theme
+
+## 🔗 Related Notes
+
+- [[creativity_and_connection]]
+- [[memory_techniques]]
+- [[zettelkasten_principles]]
+
+## 📚 References
+
+- Ahrens, S. (2017). How to Take Smart Notes
+- [[literature_note_smart_notes]]
+
+---
+
+*This knowledge is expressed entirely in my own words.*
+`,
+      '04_StructureNote/sample_structure.md': `# Structure Note: What is Zettelkasten
+
+Created: ${new Date().toISOString().split('T')[0]}
+Tags: #structure #zettelkasten #index #map #overview
+
+## 🗺️ Topic Overview
+
+This note serves as an entry point for the "Zettelkasten" theme.
+It provides navigation to all related notes.
+
+## 📖 Core Concepts
+
+### Zettelkasten Principles
+
+- [[001_zettelkasten_principles]] - Basic philosophy
+- [[connection_importance]] - Importance of connections
+- [[atomic_notes]] - Atomic note concept
+
+### Practical Methods
+
+- [[daily_note_routine]] - Daily note-taking habits
+- [[note_linking_strategies]] - Linking strategies
+- [[review_process]] - Regular review process
+
+## 📚 References and Sources
+
+### Literature Notes
+
+- [[literature_note_smart_notes]] - "How to Take Smart Notes"
+- [[literature_note_second_brain]] - "Building a Second Brain"
+
+### Fleeting Notes
+
+- [[fleeting_zettelkasten_discovery]] - First impressions of Zettelkasten
+- [[fleeting_digital_vs_analog]] - Digital vs Analog considerations
+
+## 🔍 Related Topics
+
+- [[knowledge_management]] - Broader knowledge management context
+- [[creative_thinking]] - Connection to creative thinking
+- [[learning_systems]] - Learning systems in general
+
+## 📊 Progress Status
+
+- ✅ Understanding basic concepts
+- 🔄 Exploring practical methods
+- ⭕ Building personal system (future goal)
+
+---
+
+*This structure note will be updated regularly, and new connections will be made as notes are added.*
+`
+    };
+  }
+}
+
+module.exports = {
+  createZettelkasten
+}; 

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "zettelkasten-starter",
+  "version": "1.0.0",
+  "description": "Zettelkasten-Starter is an ultimately simple library for a zettelkasten beginner",
+  "main": "index.js",
+  "bin": {
+    "create-zettelkasten": "bin/create-zettelkasten.js"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "zettelkasten",
+    "note-taking",
+    "knowledge-management",
+    "pkm",
+    "markdown",
+    "cli"
+  ],
+  "author": "Enokisan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Enokisan/zettelkasten-starter.git"
+  },
+  "homepage": "https://github.com/Enokisan/zettelkasten-starter#readme",
+  "bugs": {
+    "url": "https://github.com/Enokisan/zettelkasten-starter/issues"
+  },
+  "dependencies": {
+    "commander": "^9.5.0",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.5"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "collectCoverageFrom": [
+      "lib/**/*.js",
+      "bin/**/*.js",
+      "!node_modules/**"
+    ],
+    "coverageDirectory": "coverage",
+    "coverageReporters": [
+      "text",
+      "lcov",
+      "html"
+    ]
+  }
+}