@giwonn/claude-daily-review 0.3.13 → 0.4.0

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
       "source": {
         "source": "url",
         "url": "https://github.com/giwonn/claude-daily-review.git",
-        "ref": "v0.3.13"
+        "ref": "v0.4.0"
       },
       "description": "Auto-capture conversations for daily review and career documentation",
       "author": {

package/commands/generate.md

@@ -65,9 +65,24 @@ This outputs JSON with:
 - `needs.quarterly`: quarters that need quarterly summary
 - `needs.yearly`: years that need yearly summary
 - `logs`: raw conversation logs keyed by date
+- `gitActivity`: git commit entries keyed by date (each with `action`, `hash`, `branch`, `message`, `remote`, `ghAccount`, `cwd`)
 
 If `needs` is all empty, tell the user "해당 기간에 생성할 회고가 없습니다." and stop.
 
+## Step 1.5: Git Account Access Check
+
+If `gitActivity` has entries, verify account access before generating reviews:
+
+1. Collect unique `ghAccount` values from all git entries
+2. Run `gh auth status` to get the list of currently authenticated accounts
+3. For each `ghAccount` NOT in the authenticated list, ask the user via AskUserQuestion:
+   > "다음 GitHub 계정의 커밋 이력이 있지만, 현재 gh에 로그인되어 있지 않습니다: `{account}`"
+   - option 1: label: "로그인하기", description: "gh auth login으로 인증합니다"
+   - option 2: label: "해당 커밋 무시", description: "이 계정의 커밋 정보 없이 진행합니다"
+   - If "로그인하기": Tell the user to run `! gh auth login` in their terminal, then verify with `gh auth status`
+   - If "해당 커밋 무시": Remove that account's entries from `gitActivity`
+4. Remember the original active account (`gh auth status --active`) so you can restore it later
+
 ## 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.
@@ -84,8 +99,27 @@ For each date in `needs.daily`:
    - **배운 것**: New things learned
    - **고민한 포인트**: Decisions and reasoning
    - **질문과 답변**: Key Q&A (summarized)
+   - **커밋 내역**: If `gitActivity[date]` has entries for this project's cwd (see below)
 4. General questions go under "미분류"
 
+### Using Git Activity in Daily Reviews
+
+If `gitActivity[date]` has entries matching a project (by `cwd`):
+
+1. Switch gh account if needed: `gh auth switch --user <ghAccount>`
+2. Parse `remote` to extract `owner/repo`:
+   - SSH format `git@github.com:owner/repo.git` → `owner/repo`
+   - HTTPS format `https://github.com/owner/repo.git` → `owner/repo`
+3. Fetch commit details: `gh api repos/{owner}/{repo}/commits/{hash} --jq '.files[].filename'` to see changed files
+4. Use the conversation context + commit info to describe what was actually implemented
+5. After all lookups for a given account, switch back to the original account
+
+Include in the review:
+```markdown
+**커밋 내역:**
+- [`{short_hash}`](https://github.com/{owner}/{repo}/commit/{hash}) — {message}
+```
+
 Write via:
 ```bash
 echo '<content>' | CLAUDE_PLUGIN_DATA="${CLAUDE_PLUGIN_DATA}" node "${CLAUDE_PLUGIN_ROOT}/lib/storage-cli.mjs" write "daily/{date}.md"
@@ -193,3 +227,9 @@ Tell the user what was generated:
 > - 연간 요약: {count}개
 
 Only show lines where count > 0.
+
+If git activity was included, also report:
+> - 커밋 연동: {count}개 커밋 반영
+
+If any git entries were skipped (account not logged in), note:
+> - ⚠ 일부 커밋은 GitHub 계정 미연동으로 제외됨

package/hooks/on-stop.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 // @ts-check
 import { loadConfig, createStorageAdapter } from '../lib/config.mjs';
-import { parseHookInput, appendRawLog } from '../lib/raw-logger.mjs';
+import { parseHookInput, appendRawLog, appendGitLogs } from '../lib/raw-logger.mjs';
+import { parseGitActivity } from '../lib/git-parser.mjs';
 import { getRawDir } from '../lib/vault.mjs';
 import { formatDate } from '../lib/periods.mjs';
 import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { execSync } from 'child_process';
 import { dirname, join } from 'path';
 
 /**
@@ -58,6 +60,36 @@ async function main() {
     const date = formatDate(new Date());
     await appendRawLog(storage, sessionDir, date, input);
 
+    // Extract and save git activity from transcript
+    if (input.transcript_path) {
+      const gitEntries = parseGitActivity(input.transcript_path);
+      if (gitEntries.length > 0) {
+        // Resolve remote URL for each unique cwd
+        /** @type {Map<string, string>} */
+        const remoteByDir = new Map();
+        for (const entry of gitEntries) {
+          if (!entry.cwd || remoteByDir.has(entry.cwd)) continue;
+          try {
+            const remote = execSync('git remote get-url origin', { cwd: entry.cwd, encoding: 'utf-8', timeout: 5000 }).trim();
+            remoteByDir.set(entry.cwd, remote);
+          } catch { remoteByDir.set(entry.cwd, ''); }
+        }
+        for (const entry of gitEntries) {
+          entry.remote = remoteByDir.get(entry.cwd) || '';
+        }
+
+        // Get current gh account
+        let ghAccount = '';
+        try {
+          const status = execSync('gh auth status 2>&1', { encoding: 'utf-8', timeout: 5000 });
+          const match = status.match(/Logged in to github\.com account (\S+)/);
+          if (match) ghAccount = match[1];
+        } catch { /* gh not available or not logged in */ }
+
+        await appendGitLogs(storage, sessionDir, date, gitEntries, input.session_id, ghAccount);
+      }
+    }
+
     // Save transcript path locally for session recovery (not to remote storage)
     if (input.transcript_path) {
       const dataDir = process.env.CLAUDE_PLUGIN_DATA;

package/hooks/recover-sessions.mjs

@@ -23,19 +23,25 @@ function acquireLock() {
 
   mkdirSync(dirname(lockPath), { recursive: true });
 
-  // Check for stale lock
-  if (existsSync(lockPath)) {
+  const lockData = JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() });
+
+  try {
+    writeFileSync(lockPath, lockData, { flag: 'wx' });
+    return true;
+  } catch {
+    // File exists — check if stale
     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 */ }
+      if (age < LOCK_STALE_MS) return false;
+      unlinkSync(lockPath);
+      // Retry once after removing stale lock
+      try {
+        writeFileSync(lockPath, lockData, { flag: 'wx' });
+        return true;
+      } catch { return false; }
+    } catch { return false; }
   }
-
-  try {
-    writeFileSync(lockPath, JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() }));
-    return true;
-  } catch { return false; }
 }
 
 function releaseLock() {

package/lib/collect-raw-logs.mjs

@@ -69,6 +69,8 @@ async function main() {
   const sessions = await storage.list('.raw');
   /** @type {Record<string, Array<{type: string, message: string, cwd: string, timestamp: string}>>} */
   const logsByDate = {};
+  /** @type {Record<string, Array<{action: string, hash: string, branch: string, message: string, remote: string, ghAccount: string, cwd: string, timestamp: string}>>} */
+  const gitByDate = {};
   const affectedDates = new Set();
 
   for (const sess of sessions) {
@@ -86,6 +88,25 @@ async function main() {
       for (const line of content.trim().split('\n')) {
         try {
           const entry = JSON.parse(line);
+
+          if (entry.type === 'git') {
+            if (!gitByDate[date]) gitByDate[date] = [];
+            gitByDate[date].push({
+              action: entry.action || '',
+              hash: entry.hash || '',
+              branch: entry.branch || '',
+              message: entry.message || '',
+              remote: entry.remote || '',
+              ghAccount: entry.ghAccount || '',
+              cwd: entry.cwd || '',
+              timestamp: entry.timestamp || '',
+            });
+            if (!lastGenerated || entry.timestamp > lastGenerated) {
+              affectedDates.add(date);
+            }
+            continue;
+          }
+
           if (!logsByDate[date]) logsByDate[date] = [];
           logsByDate[date].push({
             type: entry.type || 'unknown',
@@ -104,7 +125,7 @@ async function main() {
 
   // 2. If no new entries, nothing to do
   if (affectedDates.size === 0) {
-    console.log(JSON.stringify({ needs: { daily: [], weekly: [], monthly: [], quarterly: [], yearly: [] }, logs: {} }));
+    console.log(JSON.stringify({ needs: { daily: [], weekly: [], monthly: [], quarterly: [], yearly: [] }, logs: {}, gitActivity: {} }));
     return;
   }
 
@@ -126,8 +147,10 @@ async function main() {
 
   // 4. Only include logs for affected dates
   const filteredLogs = {};
+  const filteredGit = {};
   for (const date of affectedDates) {
-    filteredLogs[date] = logsByDate[date];
+    if (logsByDate[date]) filteredLogs[date] = logsByDate[date];
+    if (gitByDate[date]) filteredGit[date] = gitByDate[date];
   }
 
   // 5. Output
@@ -145,6 +168,7 @@ async function main() {
       yearly: [...affectedYears].sort(),
     },
     logs: filteredLogs,
+    gitActivity: filteredGit,
   };
 
   console.log(JSON.stringify(result));

package/lib/git-parser.mjs

@@ -0,0 +1,79 @@
+// @ts-check
+/** @typedef {import('./types.d.ts').GitEntry} GitEntry */
+
+import { readFileSync } from 'fs';
+
+/** @param {string} content @returns {Array<GitEntry>} */
+function extractGitEntries(content) {
+  const lines = content.trim().split('\n');
+
+  /** @type {Map<string, {command: string, cwd: string, timestamp: string}>} */
+  const gitToolUses = new Map();
+  /** @type {Array<GitEntry>} */
+  const entries = [];
+
+  for (const line of lines) {
+    let parsed;
+    try { parsed = JSON.parse(line); } catch { continue; }
+    if (parsed.type !== 'assistant' || !parsed.message?.content) continue;
+
+    const contents = Array.isArray(parsed.message.content) ? parsed.message.content : [];
+    const timestamp = parsed.timestamp || '';
+    const cwd = parsed.cwd || '';
+
+    for (const block of contents) {
+      if (block.type === 'tool_use' && block.name === 'Bash' && block.input?.command) {
+        const cmd = block.input.command;
+        if (/\bgit\s+commit\b/.test(cmd)) {
+          gitToolUses.set(block.id, { command: cmd, cwd, timestamp });
+        }
+      }
+
+      if (block.type === 'tool_result' && block.tool_use_id && gitToolUses.has(block.tool_use_id)) {
+        if (block.is_error) continue;
+        const toolUse = /** @type {{command: string, cwd: string, timestamp: string}} */ (gitToolUses.get(block.tool_use_id));
+        const output = typeof block.content === 'string' ? block.content : '';
+        if (!output) continue;
+
+        const commitInfo = parseCommitOutput(output);
+        if (commitInfo) {
+          entries.push({
+            action: 'commit',
+            hash: commitInfo.hash,
+            branch: commitInfo.branch,
+            message: commitInfo.message,
+            cwd: cwd || toolUse.cwd,
+            timestamp: timestamp || toolUse.timestamp,
+          });
+        }
+      }
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Parse git commit output: "[branch hash] message"
+ * @param {string} output
+ * @returns {{hash: string, branch: string, message: string} | null}
+ */
+function parseCommitOutput(output) {
+  // Matches: [main abc1234] commit message
+  // Also: [main (root-commit) abc1234] first commit
+  const match = output.match(/\[([^\s\]]+)(?:\s+\([^)]+\))?\s+([a-f0-9]+)\]\s+(.+)/);
+  if (!match) return null;
+  return { branch: match[1], hash: match[2], message: match[3].trim() };
+}
+
+/**
+ * Parse transcript file for git commit activity.
+ * @param {string} transcriptPath
+ * @returns {Array<GitEntry>}
+ */
+export function parseGitActivity(transcriptPath) {
+  try {
+    const content = readFileSync(transcriptPath, 'utf-8');
+    return extractGitEntries(content);
+  } catch { return []; }
+}

package/lib/github-storage.mjs

@@ -15,21 +15,35 @@ export class GitHubStorageAdapter {
   }
 
   /** @private @param {string} path @returns {string} */
-  getUrl(path) { return this.basePath ? `${this.baseUrl}/${this.basePath}/${path}` : `${this.baseUrl}/${path}`; }
+  getUrl(path) {
+    if (path.split('/').includes('..')) throw new Error('Invalid path: traversal not allowed');
+    return this.basePath ? `${this.baseUrl}/${this.basePath}/${path}` : `${this.baseUrl}/${path}`;
+  }
+
+  /**
+   * @private
+   * @param {string} url
+   * @param {RequestInit} [options]
+   * @returns {Promise<Record<string, unknown> | null>}
+   */
+  async fetchOrNull(url, options) {
+    const res = await fetch(url, { ...options, headers: this.headers });
+    if (res.status === 404) return null;
+    if (!res.ok) throw new Error(`GitHub API error: ${res.status}`);
+    return /** @type {Record<string, unknown>} */ (await res.json());
+  }
 
   /** @private @param {string} path @returns {Promise<string | null>} */
   async getSha(path) {
-    const res = await fetch(this.getUrl(path), { method: 'GET', headers: this.headers });
-    if (res.status === 404) return null;
-    const data = /** @type {Record<string, unknown>} */ (await res.json());
+    const data = await this.fetchOrNull(this.getUrl(path), { method: 'GET' });
+    if (!data) return null;
     return /** @type {string | null} */ (data.sha || null);
   }
 
   /** @param {string} path @returns {Promise<string | null>} */
   async read(path) {
-    const res = await fetch(this.getUrl(path), { method: 'GET', headers: this.headers });
-    if (res.status === 404) return null;
-    const data = /** @type {Record<string, unknown>} */ (await res.json());
+    const data = await this.fetchOrNull(this.getUrl(path), { method: 'GET' });
+    if (!data) return null;
     return Buffer.from(/** @type {string} */ (data.content), 'base64').toString('utf-8');
   }
 
@@ -40,10 +54,13 @@ export class GitHubStorageAdapter {
     const body = { message: `update ${path}`, content: Buffer.from(content).toString('base64') };
     if (sha) body.sha = sha;
     const res = await fetch(this.getUrl(path), { method: 'PUT', headers: this.headers, body: JSON.stringify(body) });
-    if (!res.ok && res.status === 409) {
+    if (res.status === 409) {
       const freshSha = await this.getSha(path);
       if (freshSha) body.sha = freshSha;
-      await fetch(this.getUrl(path), { method: 'PUT', headers: this.headers, body: JSON.stringify(body) });
+      const retry = await fetch(this.getUrl(path), { method: 'PUT', headers: this.headers, body: JSON.stringify(body) });
+      if (!retry.ok) throw new Error(`GitHub API error: ${retry.status}`);
+    } else if (!res.ok) {
+      throw new Error(`GitHub API error: ${res.status}`);
     }
   }
 
@@ -55,16 +72,14 @@ export class GitHubStorageAdapter {
 
   /** @param {string} path @returns {Promise<boolean>} */
   async exists(path) {
-    const res = await fetch(this.getUrl(path), { method: 'GET', headers: this.headers });
-    return res.status !== 404;
+    const data = await this.fetchOrNull(this.getUrl(path), { method: 'GET' });
+    return data !== null;
   }
 
   /** @param {string} dir @returns {Promise<string[]>} */
   async list(dir) {
-    const res = await fetch(this.getUrl(dir), { method: 'GET', headers: this.headers });
-    if (res.status === 404) return [];
-    const data = await res.json();
-    if (!Array.isArray(data)) return [];
+    const data = await this.fetchOrNull(this.getUrl(dir), { method: 'GET' });
+    if (!data || !Array.isArray(data)) return [];
     return data.map((/** @type {{ name: string }} */ entry) => entry.name);
   }
 
@@ -73,9 +88,8 @@ export class GitHubStorageAdapter {
 
   /** @param {string} path @returns {Promise<boolean>} */
   async isDirectory(path) {
-    const res = await fetch(this.getUrl(path), { method: 'GET', headers: this.headers });
-    if (res.status === 404) return false;
-    const data = await res.json();
+    const data = await this.fetchOrNull(this.getUrl(path), { method: 'GET' });
+    if (!data) return false;
     return Array.isArray(data);
   }
 }

package/lib/raw-logger.mjs

@@ -10,6 +10,8 @@ export function parseHookInput(raw) {
   return /** @type {HookInput} */ (parsed);
 }
 
+/** @typedef {import('./types.d.ts').GitEntry} GitEntry */
+
 /** @param {StorageAdapter} storage @param {string} sessionDir @param {string} date @param {HookInput} entry @returns {Promise<void>} */
 export async function appendRawLog(storage, sessionDir, date, entry) {
   await storage.mkdir(sessionDir);
@@ -31,3 +33,23 @@ export async function appendRawLog(storage, sessionDir, date, entry) {
     await storage.append(logPath, lines);
   }
 }
+
+/**
+ * Append git activity entries to raw log.
+ * @param {StorageAdapter} storage
+ * @param {string} sessionDir
+ * @param {string} date
+ * @param {Array<GitEntry>} gitEntries
+ * @param {string} sessionId
+ * @param {string} ghAccount
+ * @returns {Promise<void>}
+ */
+export async function appendGitLogs(storage, sessionDir, date, gitEntries, sessionId, ghAccount) {
+  if (gitEntries.length === 0) return;
+  await storage.mkdir(sessionDir);
+  const logPath = `${sessionDir}/${date}.jsonl`;
+  const lines = gitEntries.map(e =>
+    JSON.stringify({ type: 'git', action: e.action, hash: e.hash, branch: e.branch, message: e.message, remote: e.remote, cwd: e.cwd, ghAccount, session_id: sessionId, timestamp: e.timestamp })
+  ).join('\n') + '\n';
+  await storage.append(logPath, lines);
+}

package/lib/storage.mjs

@@ -2,7 +2,7 @@
 /** @typedef {import('./types.d.ts').StorageAdapter} StorageAdapter */
 
 import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'fs';
-import { dirname, join } from 'path';
+import { dirname, join, resolve as pathResolve } from 'path';
 
 /** @implements {StorageAdapter} */
 export class LocalStorageAdapter {
@@ -14,7 +14,11 @@ export class LocalStorageAdapter {
 
   /** @private @param {string} path @returns {string} */
   resolve(path) {
-    return join(this.basePath, path);
+    const full = pathResolve(this.basePath, path);
+    if (full !== this.basePath && !full.startsWith(this.basePath + '/')) {
+      throw new Error('Invalid path: traversal outside base directory');
+    }
+    return full;
   }
 
   /** @param {string} path @returns {Promise<string | null>} */

package/lib/types.d.ts

@@ -55,6 +55,16 @@ export interface HookInput {
   [key: string]: unknown;
 }
 
+export interface GitEntry {
+  action: 'commit';
+  hash: string;
+  branch: string;
+  message?: string;
+  remote?: string;
+  cwd: string;
+  timestamp: string;
+}
+
 export interface DeviceCodeResponse {
   device_code: string;
   user_code: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giwonn/claude-daily-review",
-  "version": "0.3.13",
+  "version": "0.4.0",
   "type": "module",
   "description": "Claude Code plugin that auto-captures conversations for daily review and career documentation",
   "repository": {