@giwonn/claude-daily-review 0.3.2 → 0.3.4

package/commands/generate.md

@@ -0,0 +1,195 @@
+---
+description: Generate reviews from raw conversation logs (supports natural language targeting)
+allowed-tools: ["Read", "Write", "Bash"]
+---
+
+# Generate Reviews
+
+## Important Rules
+
+- Write all review content in Korean.
+- **NEVER show raw error messages or file paths to the user.**
+- Use the user's profile to add business context.
+- Today's date: use the system date for resolving relative expressions.
+
+## Step 0: Interpret User Request
+
+The user may provide a natural language request as arguments. Parse their intent to determine:
+
+1. **Date scope** — which dates/periods to generate
+2. **Period type** — daily, weekly, monthly, quarterly, yearly (or all cascading)
+3. **Project filter** — specific project name (optional)
+4. **Force regeneration** — whether to regenerate already-generated reviews
+
+### Interpretation Examples
+
+| User input | from | to | force | Period type | Project |
+|---|---|---|---|---|---|
+| (empty) | - | - | no | all missing | all |
+| "어제 회고" | yesterday | yesterday | yes | daily | all |
+| "3월 15일 회고" | 2026-03-15 | 2026-03-15 | yes | daily | all |
+| "지난주 주간 회고" | (week start) | (week end) | yes | weekly | all |
+| "이번달 회고" | (month start) | today | yes | daily+monthly | all |
+| "1분기 회고" | Q1 start | Q1 end | yes | quarterly | all |
+| "my-app 프로젝트 3월 회고" | 03-01 | 03-31 | yes | daily+monthly | my-app |
+| "올해 회고 다시 만들어줘" | year start | today | yes | all cascade | all |
+| "3월 1일~15일" | 03-01 | 03-15 | yes | daily | all |
+
+**Rules:**
+- If the user specifies a specific date/period, set `force` to `yes` (they want it regenerated).
+- If no input is given, run in default mode (generate only missing reviews, no force).
+- For period types like "주간", "월간", "분기", "연간": generate the requested summary AND any prerequisite lower-level reviews needed as input.
+- When the user mentions a project name, generate reviews for all dates but only include logs from that project's cwd.
+
+## Step 1: Collect Data
+
+Based on Step 0 interpretation, build the command:
+
+```bash
+CLAUDE_PLUGIN_DATA="${CLAUDE_PLUGIN_DATA}" node "${CLAUDE_PLUGIN_ROOT}/lib/collect-raw-logs.mjs" [OPTIONS]
+```
+
+Options (all optional):
+- `--from YYYY-MM-DD` — start date filter
+- `--to YYYY-MM-DD` — end date filter
+- `--force` — include dates even if already generated
+
+If no options, runs in default incremental mode (only new logs since last generation).
+
+This outputs JSON with:
+- `profile`: user's company/role/team/context
+- `language`: review language
+- `needs.daily`: dates that need daily review generation
+- `needs.weekly`: weeks that need weekly summary
+- `needs.monthly`: months that need monthly summary
+- `needs.quarterly`: quarters that need quarterly summary
+- `needs.yearly`: years that need yearly summary
+- `logs`: raw conversation logs keyed by date
+
+If `needs` is all empty, tell the user "해당 기간에 생성할 회고가 없습니다." and stop.
+
+## Step 2: Apply Filters
+
+- **Project filter**: If the user requested a specific project, filter `logs[date]` entries to only include those where the last path segment of `cwd` matches the project name.
+- **Period type filter**: If the user only requested a specific period type (e.g., "주간 회고"), only generate that type and its prerequisites. For example, if weekly is requested, generate daily reviews first (as input), then the weekly summary.
+
+## Step 3: Generate Daily Reviews
+
+For each date in `needs.daily`:
+
+1. Take all log entries from `logs[date]`
+2. Group by `cwd` (last path segment = project name)
+3. For each project, analyze user/assistant pairs and extract:
+   - **작업 요약**: What was accomplished (use profile for business context)
+   - **배운 것**: New things learned
+   - **고민한 포인트**: Decisions and reasoning
+   - **질문과 답변**: Key Q&A (summarized)
+4. General questions go under "미분류"
+
+Write via:
+```bash
+echo '<content>' | CLAUDE_PLUGIN_DATA="${CLAUDE_PLUGIN_DATA}" node "${CLAUDE_PLUGIN_ROOT}/lib/storage-cli.mjs" write "daily/{date}.md"
+```
+
+Format:
+```markdown
+---
+date: {date}
+type: daily-review
+projects: [{names}]
+---
+
+# {date} Daily Review
+
+## [{project}] {title}
+**작업 요약:** {summary}
+**배운 것:**
+- {item}
+**고민한 포인트:**
+- {decision} → {choice} ({reason})
+**질문과 답변:**
+- Q: {question}
+  → A: {answer}
+
+## 미분류
+- Q: {question}
+  → A: {answer}
+```
+
+## Step 4: Generate Weekly Summaries
+
+For each week in `needs.weekly`:
+
+1. Read the daily reviews that belong to this week using:
+```bash
+CLAUDE_PLUGIN_DATA="${CLAUDE_PLUGIN_DATA}" node "${CLAUDE_PLUGIN_ROOT}/lib/storage-cli.mjs" read "daily/{date}.md"
+```
+2. Summarize into weekly review with:
+   - 주요 성과
+   - 기술 스택 활용
+   - 핵심 의사결정
+   - 성장 포인트
+
+Write to `weekly/{week}.md`.
+
+## Step 5: Generate Monthly Summaries
+
+For each month in `needs.monthly`:
+
+1. Read weekly reviews for that month (or daily reviews if weekly is empty)
+2. Summarize into monthly review with:
+   - 프로젝트별 진행 요약
+   - 이번 달 핵심 성장
+   - 기술 스택
+   - 주요 의사결정 기록
+
+Write to `monthly/{month}.md`.
+
+## Step 6: Generate Quarterly Summaries
+
+For each quarter in `needs.quarterly`:
+
+1. Read monthly reviews for that quarter
+2. Summarize with:
+   - 분기 성과 요약
+   - 핵심 역량 성장
+   - 기술 스택 총괄
+   - 경력기술서 하이라이트
+
+Write to `quarterly/{quarter}.md`.
+
+## Step 7: Generate Yearly Summaries
+
+For each year in `needs.yearly`:
+
+1. Read quarterly reviews for that year
+2. Summarize with:
+   - 연간 프로젝트 총괄
+   - 핵심 역량 맵
+   - 이력서용 요약
+   - 경력기술서용 상세
+
+Write to `yearly/{year}.md`.
+
+## Step 8: Update last-generated timestamp
+
+**Only update if running in default mode (no user-specified scope).**
+
+If the user requested a specific date/period/project, do NOT update `last-generated.json` — the incremental tracking should remain unchanged.
+
+If running in default mode, save the `newTimestamp` from Step 1:
+```bash
+echo '{"timestamp":"NEW_TIMESTAMP_VALUE"}' > "${CLAUDE_PLUGIN_DATA}/last-generated.json"
+```
+
+## Step 9: Report
+
+Tell the user what was generated:
+> "회고 생성 완료!"
+> - 일일 회고: {count}개
+> - 주간 요약: {count}개
+> - 월간 요약: {count}개
+> - 분기 요약: {count}개
+> - 연간 요약: {count}개
+
+Only show lines where count > 0.

package/hooks/hooks.json

@@ -12,17 +12,6 @@
         ]
       }
     ],
-    "SessionEnd": [
-      {
-        "hooks": [
-          {
-            "type": "agent",
-            "prompt": "Follow the instructions in the file at ${CLAUDE_PLUGIN_ROOT}/prompts/session-end.md exactly. The CLAUDE_PLUGIN_DATA directory is: ${CLAUDE_PLUGIN_DATA}. The plugin root is: ${CLAUDE_PLUGIN_ROOT}",
-            "timeout": 120
-          }
-        ]
-      }
-    ],
     "SessionStart": [
       {
         "matcher": "startup",
@@ -31,6 +20,12 @@
             "type": "command",
             "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cmd\" session-start-check",
             "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/recover-sessions.mjs\"",
+            "async": true,
+            "timeout": 30
           }
         ]
       }

package/hooks/on-stop.mjs

@@ -4,6 +4,34 @@ import { loadConfig, createStorageAdapter } from '../lib/config.mjs';
 import { parseHookInput, appendRawLog } from '../lib/raw-logger.mjs';
 import { getRawDir } from '../lib/vault.mjs';
 import { formatDate } from '../lib/periods.mjs';
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+
+/**
+ * Read the last user message and its timestamp from transcript file
+ * @param {string} transcriptPath
+ * @returns {{ message: string, timestamp: string }}
+ */
+function getLastUserEntry(transcriptPath) {
+  try {
+    const content = readFileSync(transcriptPath, 'utf-8');
+    const lines = content.trim().split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (entry.type !== 'user') continue;
+        const msgContent = entry.message?.content;
+        const ts = entry.timestamp || '';
+        if (typeof msgContent === 'string' && msgContent.trim()) return { message: msgContent, timestamp: ts };
+        if (Array.isArray(msgContent)) {
+          const textPart = msgContent.find(p => p.type === 'text' && p.text?.trim());
+          if (textPart) return { message: textPart.text, timestamp: ts };
+        }
+      } catch { continue; }
+    }
+  } catch { /* transcript not accessible */ }
+  return { message: '', timestamp: '' };
+}
 
 async function main() {
   try {
@@ -14,11 +42,39 @@ async function main() {
     process.stdin.setEncoding('utf-8');
     for await (const chunk of process.stdin) { data += chunk; }
     const input = parseHookInput(data);
+
+    // Get user message + timestamp from transcript
+    let userMessage = '';
+    let userTimestamp = '';
+    if (input.transcript_path) {
+      const userEntry = getLastUserEntry(input.transcript_path);
+      userMessage = userEntry.message;
+      userTimestamp = userEntry.timestamp;
+    }
+    input.last_user_message = userMessage;
+    input.user_timestamp = userTimestamp;
+
     const sessionDir = getRawDir(input.session_id);
     const date = formatDate(new Date());
     await appendRawLog(storage, sessionDir, date, input);
-  } catch {
-    // async hook — fail silently
+
+    // Save transcript path for session recovery
+    if (input.transcript_path) {
+      const metaPath = `${sessionDir}/.meta.json`;
+      const meta = JSON.stringify({ transcript_path: input.transcript_path, session_id: input.session_id });
+      await storage.write(metaPath, meta);
+    }
+  } catch (err) {
+    try {
+      const logDir = process.env.CLAUDE_PLUGIN_DATA;
+      if (logDir) {
+        const logPath = join(logDir, 'error.log');
+        mkdirSync(dirname(logPath), { recursive: true });
+        writeFileSync(logPath, `${new Date().toISOString()} ${err.message}\n${err.stack}\n`, { flag: 'a' });
+      }
+    } catch {
+      // truly silent
+    }
   }
 }
 main();

package/hooks/recover-sessions.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+// @ts-check
+// Recovers missing raw log entries from transcript files on SessionStart.
+// Uses a lock file to prevent concurrent recovery across multiple sessions.
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { loadConfig, createStorageAdapter } from '../lib/config.mjs';
+import { formatDate } from '../lib/periods.mjs';
+import { getRawDir } from '../lib/vault.mjs';
+
+const LOCK_STALE_MS = 120_000; // 2 minutes
+
+function getLockPath() {
+  const dataDir = process.env.CLAUDE_PLUGIN_DATA;
+  if (!dataDir) return null;
+  return join(dataDir, 'recover.lock');
+}
+
+/** @returns {boolean} */
+function acquireLock() {
+  const lockPath = getLockPath();
+  if (!lockPath) return false;
+
+  mkdirSync(dirname(lockPath), { recursive: true });
+
+  // Check for stale lock
+  if (existsSync(lockPath)) {
+    try {
+      const lock = JSON.parse(readFileSync(lockPath, 'utf-8'));
+      const age = Date.now() - new Date(lock.timestamp).getTime();
+      if (age < LOCK_STALE_MS) return false; // Another session is recovering
+    } catch { /* corrupt lock, take over */ }
+  }
+
+  try {
+    writeFileSync(lockPath, JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() }));
+    return true;
+  } catch { return false; }
+}
+
+function releaseLock() {
+  const lockPath = getLockPath();
+  if (!lockPath) return;
+  try { unlinkSync(lockPath); } catch { /* already removed */ }
+}
+
+/**
+ * Parse transcript JSONL and extract user/assistant message pairs with timestamps.
+ * @param {string} transcriptPath
+ * @returns {Array<{type: string, message: string, cwd: string, timestamp: string}>}
+ */
+function parseTranscript(transcriptPath) {
+  try {
+    const content = readFileSync(transcriptPath, 'utf-8');
+    const lines = content.trim().split('\n');
+    /** @type {Array<{type: string, message: string, cwd: string, timestamp: string}>} */
+    const entries = [];
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        const ts = entry.timestamp || '';
+        const cwd = entry.cwd || '';
+
+        if (entry.type === 'user') {
+          const msgContent = entry.message?.content;
+          let text = '';
+          if (typeof msgContent === 'string') text = msgContent;
+          else if (Array.isArray(msgContent)) {
+            const textPart = msgContent.find(p => p.type === 'text' && p.text?.trim());
+            if (textPart) text = textPart.text;
+          }
+          if (text.trim()) entries.push({ type: 'user', message: text, cwd, timestamp: ts });
+        } else if (entry.type === 'assistant') {
+          const msgContent = entry.message?.content;
+          let text = '';
+          if (typeof msgContent === 'string') text = msgContent;
+          else if (Array.isArray(msgContent)) {
+            const textParts = msgContent.filter(p => p.type === 'text').map(p => p.text);
+            text = textParts.join('\n');
+          }
+          if (text.trim()) entries.push({ type: 'assistant', message: text, cwd, timestamp: ts });
+        }
+      } catch { continue; }
+    }
+    return entries;
+  } catch { return []; }
+}
+
+/**
+ * Count raw log entries for a session across all date files.
+ * @param {import('../lib/types.d.ts').StorageAdapter} storage
+ * @param {string} sessionDir
+ * @returns {Promise<{count: number, timestamps: Set<string>}>}
+ */
+async function getRawLogState(storage, sessionDir) {
+  const timestamps = new Set();
+  let count = 0;
+  try {
+    const files = await storage.list(sessionDir);
+    for (const file of files) {
+      if (!file.endsWith('.jsonl')) continue;
+      const content = await storage.read(`${sessionDir}/${file}`);
+      if (!content) continue;
+      for (const line of content.trim().split('\n')) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.timestamp) timestamps.add(entry.timestamp);
+          count++;
+        } catch { continue; }
+      }
+    }
+  } catch { /* session dir might not be listable */ }
+  return { count, timestamps };
+}
+
+async function main() {
+  if (!acquireLock()) return; // Another session is already recovering
+
+  try {
+    const config = loadConfig();
+    if (!config) return;
+    const storage = await createStorageAdapter(config);
+
+    const sessions = await storage.list('.raw');
+
+    for (const sessionId of sessions) {
+      const sessionDir = getRawDir(sessionId);
+
+      // Read .meta.json for transcript path
+      const metaContent = await storage.read(`${sessionDir}/.meta.json`);
+      if (!metaContent) continue;
+
+      let meta;
+      try { meta = JSON.parse(metaContent); } catch { continue; }
+      if (!meta.transcript_path || !existsSync(meta.transcript_path)) continue;
+
+      // Compare transcript entries with raw log entries
+      const transcriptEntries = parseTranscript(meta.transcript_path);
+      if (transcriptEntries.length === 0) continue;
+
+      const rawState = await getRawLogState(storage, sessionDir);
+
+      // If raw logs have same or more entries, skip
+      if (rawState.count >= transcriptEntries.length) continue;
+
+      // Find missing entries (by timestamp) and append them
+      const missingByDate = {};
+      for (const entry of transcriptEntries) {
+        if (rawState.timestamps.has(entry.timestamp)) continue;
+        const date = entry.timestamp ? formatDate(new Date(entry.timestamp)) : formatDate(new Date());
+        if (!missingByDate[date]) missingByDate[date] = [];
+        missingByDate[date].push(entry);
+      }
+
+      // Append missing entries to appropriate date files
+      for (const [date, entries] of Object.entries(missingByDate)) {
+        const logPath = `${sessionDir}/${date}.jsonl`;
+        const lines = entries.map(e =>
+          JSON.stringify({ type: e.type, message: e.message, session_id: sessionId, cwd: e.cwd, timestamp: e.timestamp })
+        ).join('\n') + '\n';
+        await storage.append(logPath, lines);
+      }
+    }
+  } catch (err) {
+    try {
+      const logDir = process.env.CLAUDE_PLUGIN_DATA;
+      if (logDir) {
+        const logPath = join(logDir, 'error.log');
+        mkdirSync(dirname(logPath), { recursive: true });
+        writeFileSync(logPath, `${new Date().toISOString()} recover: ${err.message}\n`, { flag: 'a' });
+      }
+    } catch { /* silent */ }
+  } finally {
+    releaseLock();
+  }
+}
+
+main();

package/hooks/session-start-check

@@ -4,15 +4,7 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PLUGIN_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
 
-result=$(node -e "
-import { loadConfig } from '${PLUGIN_ROOT}/lib/config.mjs';
-try {
-  const config = loadConfig();
-  if (!config) process.stdout.write('NEEDS_SETUP');
-} catch {
-  process.stdout.write('NEEDS_SETUP');
-}
-" 2>/dev/null || echo "NEEDS_SETUP")
+result=$(node "${PLUGIN_ROOT}/lib/check-config.mjs" 2>/dev/null || echo "NEEDS_SETUP")
 
 if [ "$result" = "NEEDS_SETUP" ]; then
   msg='<important-reminder>IN YOUR FIRST REPLY YOU MUST TELL THE USER: daily-review 플러그인이 아직 설정되지 않았습니다. /daily-review-setup 을 실행해주세요.</important-reminder>'

package/lib/check-config.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { loadConfig } from './config.mjs';
+try {
+  const config = loadConfig();
+  if (!config) process.stdout.write('NEEDS_SETUP');
+} catch {
+  process.stdout.write('NEEDS_SETUP');
+}

package/lib/collect-raw-logs.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+// Reads raw logs since last generation, determines what reviews need updating
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { loadConfig, createStorageAdapter } from './config.mjs';
+import { getISOWeek, getISOWeekYear, getQuarter } from './periods.mjs';
+
+/** @param {Date} date @returns {string} */
+function toWeekKey(date) {
+  return `${getISOWeekYear(date)}-W${String(getISOWeek(date)).padStart(2, '0')}`;
+}
+
+/** @param {Date} date @returns {string} */
+function toMonthKey(date) {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
+}
+
+/** @param {Date} date @returns {string} */
+function toQuarterKey(date) {
+  return `${date.getFullYear()}-Q${getQuarter(date)}`;
+}
+
+/** @param {Date} date @returns {string} */
+function toYearKey(date) {
+  return `${date.getFullYear()}`;
+}
+
+function getLastGenerated() {
+  try {
+    const dataDir = process.env.CLAUDE_PLUGIN_DATA;
+    if (!dataDir) return null;
+    const path = join(dataDir, 'last-generated.json');
+    if (!existsSync(path)) return null;
+    const data = JSON.parse(readFileSync(path, 'utf-8'));
+    return data.timestamp || null;
+  } catch { return null; }
+}
+
+function saveLastGenerated(timestamp) {
+  try {
+    const dataDir = process.env.CLAUDE_PLUGIN_DATA;
+    if (!dataDir) return;
+    const path = join(dataDir, 'last-generated.json');
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ timestamp }), 'utf-8');
+  } catch {}
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = { from: null, to: null, force: false };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--from' && args[i + 1]) opts.from = args[++i];
+    else if (args[i] === '--to' && args[i + 1]) opts.to = args[++i];
+    else if (args[i] === '--force') opts.force = true;
+  }
+  return opts;
+}
+
+async function main() {
+  const config = loadConfig();
+  if (!config) { console.log('{}'); return; }
+  const storage = await createStorageAdapter(config);
+  const opts = parseArgs();
+
+  const lastGenerated = opts.force ? null : getLastGenerated();
+
+  // 1. Collect raw logs, filter by lastGenerated timestamp
+  const sessions = await storage.list('.raw');
+  /** @type {Record<string, Array<{type: string, message: string, cwd: string, timestamp: string}>>} */
+  const logsByDate = {};
+  const affectedDates = new Set();
+
+  for (const sess of sessions) {
+    const files = await storage.list('.raw/' + sess);
+    for (const file of files) {
+      if (!file.endsWith('.jsonl')) continue;
+      const date = file.replace('.jsonl', '');
+      const content = await storage.read('.raw/' + sess + '/' + file);
+      if (!content) continue;
+
+      // Apply date range filter
+      if (opts.from && date < opts.from) continue;
+      if (opts.to && date > opts.to) continue;
+
+      for (const line of content.trim().split('\n')) {
+        try {
+          const entry = JSON.parse(line);
+          if (!logsByDate[date]) logsByDate[date] = [];
+          logsByDate[date].push({
+            type: entry.type || 'unknown',
+            message: entry.message || '',
+            cwd: entry.cwd || '',
+            timestamp: entry.timestamp || '',
+          });
+
+          if (!lastGenerated || entry.timestamp > lastGenerated) {
+            affectedDates.add(date);
+          }
+        } catch {}
+      }
+    }
+  }
+
+  // 2. If no new entries, nothing to do
+  if (affectedDates.size === 0) {
+    console.log(JSON.stringify({ needs: { daily: [], weekly: [], monthly: [], quarterly: [], yearly: [] }, logs: {} }));
+    return;
+  }
+
+  // 3. Determine which periods are affected by the changed dates
+  const periods = config.periods;
+  const affectedWeeks = new Set();
+  const affectedMonths = new Set();
+  const affectedQuarters = new Set();
+  const affectedYears = new Set();
+
+  for (const dateStr of affectedDates) {
+    const [y, m, d] = dateStr.split('-').map(Number);
+    const date = new Date(y, m - 1, d);
+    if (periods.weekly) affectedWeeks.add(toWeekKey(date));
+    if (periods.monthly) affectedMonths.add(toMonthKey(date));
+    if (periods.quarterly) affectedQuarters.add(toQuarterKey(date));
+    if (periods.yearly) affectedYears.add(toYearKey(date));
+  }
+
+  // 4. Only include logs for affected dates
+  const filteredLogs = {};
+  for (const date of affectedDates) {
+    filteredLogs[date] = logsByDate[date];
+  }
+
+  // 5. Output
+  const now = new Date().toISOString();
+  const result = {
+    profile: config.profile,
+    language: config.language,
+    lastGenerated: lastGenerated,
+    newTimestamp: now,
+    needs: {
+      daily: [...affectedDates].sort(),
+      weekly: [...affectedWeeks].sort(),
+      monthly: [...affectedMonths].sort(),
+      quarterly: [...affectedQuarters].sort(),
+      yearly: [...affectedYears].sort(),
+    },
+    logs: filteredLogs,
+  };
+
+  console.log(JSON.stringify(result));
+}
+
+main().catch(() => console.log('{}'));

package/lib/config.mjs

@@ -98,7 +98,7 @@ export function createDefaultLocalConfig(basePath) {
 /** @param {string} owner @param {string} repo @param {string} token @returns {Config} */
 export function createDefaultGitHubConfig(owner, repo, token) {
   return {
-    storage: { type: 'github', github: { owner, repo, token, basePath: 'daily-review' } },
+    storage: { type: 'github', github: { owner, repo, token, basePath: '' } },
     language: 'ko',
     periods: { daily: true, weekly: true, monthly: true, quarterly: true, yearly: false },
     profile: { company: '', role: '', team: '', context: '' },

package/lib/create-dirs.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+const configPath = path.join(process.env.CLAUDE_PLUGIN_DATA, 'config.json');
+const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+const base = config.storage.local.basePath;
+const dirs = ['daily', 'projects', 'uncategorized', '.raw', '.reviews'];
+if (config.periods.weekly) dirs.push('weekly');
+if (config.periods.monthly) dirs.push('monthly');
+if (config.periods.quarterly) dirs.push('quarterly');
+if (config.periods.yearly) dirs.push('yearly');
+dirs.forEach(d => fs.mkdirSync(path.join(base, d), { recursive: true }));
+console.log('Directories created at: ' + base);