Commit 025527ef0731

@@ -2255,7 +2255,8 @@ parameter), remove all other windows so the capture buffer fills the frame."
 ;; Daily Plan - Jira/GitHub → org-mode scheduling
 (use-package daily-plan
   :commands (daily-plan-show daily-plan-inbox daily-plan-weekly
-             daily-plan-schedule daily-plan-schedule-at-point)
+             daily-plan-review daily-plan-schedule
+             daily-plan-schedule-at-point daily-plan-yank-markdown)
   :bind-keymap ("C-c d" . daily-plan-prefix-map)
   :config
   (defvar daily-plan-prefix-map
@@ -2263,6 +2264,7 @@ parameter), remove all other windows so the capture buffer fills the frame."
       (define-key map "d" #'daily-plan-show)
       (define-key map "i" #'daily-plan-inbox)
       (define-key map "w" #'daily-plan-weekly)
+      (define-key map "r" #'daily-plan-review)
       (define-key map "s" #'daily-plan-schedule)
       map)
     "Keymap for daily-plan commands under C-c d."))

@@ -34,7 +34,6 @@ in
   nix-flake-update = pkgs.callPackage ../tools/nix-flake-update { };
   slack-archive = pkgs.callPackage ../tools/slack-archive { };
   gcal-to-org = pkgs.callPackage ../tools/gcal-to-org { };
-  review-tool = pkgs.callPackage ../tools/review-tool { };
   daily-plan = pkgs.callPackage ../tools/daily-plan { };
   github-notif-manager = pkgs.callPackage ../tools/github-notif-manager { };
   beets-lidarr-fields = pkgs.python3Packages.callPackage ./beets-lidarr-fields { };

@@ -9,11 +9,15 @@
 ;;   RET - open item URL in browser
 ;;   g   - refresh buffer
 ;;   q   - quit
+;;   y   - yank buffer as markdown (for reports)
+;;   p   - switch period (weekly/review buffers)
+;;   TAB - cycle section visibility
 ;;
 ;; Interactive commands:
 ;;   M-x daily-plan-show      - today's plan
 ;;   M-x daily-plan-inbox     - new items since last check
 ;;   M-x daily-plan-weekly    - weekly review
+;;   M-x daily-plan-review    - full activity review (markdown output)
 ;;   M-x daily-plan-schedule  - schedule by key
 
 ;;; Code:
@@ -27,6 +31,18 @@
 (defvar daily-plan-org-file (expand-file-name "~/desktop/org/todos.org")
   "Path to the org file for scheduling.")
 
+(defvar-local daily-plan--current-period nil
+  "Current period for review/weekly buffers.")
+
+(defvar-local daily-plan--current-command nil
+  "Current command for refresh.")
+
+(defvar-local daily-plan--current-args nil
+  "Current args for refresh.")
+
+(defvar-local daily-plan--current-render-fn nil
+  "Current render function for refresh.")
+
 ;; ── JSON helpers ──
 
 (defun daily-plan--run-json (&rest args)
@@ -54,6 +70,10 @@
     (define-key map (kbd "RET") #'daily-plan-open-at-point)
     (define-key map (kbd "g") #'daily-plan-refresh)
     (define-key map (kbd "q") #'quit-window)
+    (define-key map (kbd "y") #'daily-plan-yank-markdown)
+    (define-key map (kbd "p") #'daily-plan-switch-period)
+    (define-key map (kbd "TAB") #'org-cycle)
+    (define-key map (kbd "S-TAB") #'org-shifttab)
     map)
   "Keymap for `daily-plan-mode'.")
 
@@ -63,7 +83,7 @@
   (read-only-mode 1)
   (setq-local buffer-read-only t))
 
-;; ── Rendering ──
+;; ── Rendering helpers ──
 
 (defun daily-plan--insert-jira-item (item)
   "Insert a single Jira ITEM as an org list entry with text properties."
@@ -97,6 +117,41 @@
         (funcall insert-fn item))
     (insert (format "- %s\n" (or empty-msg "(none)")))))
 
+(defun daily-plan--insert-org-done-item (item)
+  "Insert a completed org ITEM."
+  (let-alist item
+    (insert (format "- ✓ %s /(%s)/\n" .title .completed_at))))
+
+(defun daily-plan--insert-discussion-item (item)
+  "Insert a GitHub discussion ITEM."
+  (let-alist item
+    (let ((start (point)))
+      (insert (format "- [[%s][%s]] %s" .url .repo .title))
+      (when (and .category (not (string-empty-p .category)))
+        (insert (format " =[%s]=" .category)))
+      (insert "\n")
+      (put-text-property start (point) 'daily-plan-url .url)
+      (put-text-property start (point) 'daily-plan-type "discussion"))))
+
+(defun daily-plan--insert-comment-item (item)
+  "Insert a GitHub comment ITEM."
+  (let-alist item
+    (let ((start (point))
+          (ref (format "%s#%d" .repo .issue_number)))
+      (insert (format "- [[%s][%s]] %s\n" .url ref .issue_title))
+      (put-text-property start (point) 'daily-plan-url .url)
+      (put-text-property start (point) 'daily-plan-type "comment"))))
+
+(defun daily-plan--insert-ai-item (item)
+  "Insert an AI session ITEM."
+  (let-alist item
+    (insert (format "- *%s* %s" .type .title))
+    (when (and .project (not (string-empty-p .project)))
+      (insert (format " =[%s]=" .project)))
+    (insert (format " /(%s)/\n" .date))))
+
+;; ── Render: show ──
+
 (defun daily-plan--render-show (data)
   "Render show DATA into current buffer."
   (let-alist data
@@ -124,14 +179,15 @@
     (insert "\n** GitHub — Your Open PRs\n")
     (daily-plan--insert-items .github_prs #'daily-plan--insert-gh-item nil)))
 
+;; ── Render: inbox ──
+
 (defun daily-plan--insert-advisory (item)
   "Insert a GitHub security advisory ITEM."
   (let-alist item
     (let ((start (point))
           (id (or .cve_id .ghsa_id)))
-      (insert (format "- [[%s][%s]] %s =%s= /%s/"
+      (insert (format "- [[%s][%s]] %s =%s= /%s/\n"
                       .url id .summary .severity .repo))
-      (insert "\n")
       (put-text-property start (point) 'daily-plan-key id)
       (put-text-property start (point) 'daily-plan-url .url)
       (put-text-property start (point) 'daily-plan-type "advisory"))))
@@ -141,9 +197,8 @@
   (let-alist item
     (let ((start (point))
           (id (or .cve "dependabot")))
-      (insert (format "- [[%s][%s]] %s =%s= ~%s~ /%s/"
+      (insert (format "- [[%s][%s]] %s =%s= ~%s~ /%s/\n"
                       .url id .summary .severity .package .repo))
-      (insert "\n")
       (put-text-property start (point) 'daily-plan-key id)
       (put-text-property start (point) 'daily-plan-url .url)
       (put-text-property start (point) 'daily-plan-type "dependabot"))))
@@ -153,10 +208,10 @@
   (let-alist data
     (insert (format "* Inbox — Since %s\n\n" .since))
 
-    (insert "** GitHub — Security Advisories (triage/draft)  :security:\n")
+    (insert "** Security Advisories (triage/draft)  :security:\n")
     (daily-plan--insert-items .github_security_advisories #'daily-plan--insert-advisory nil)
 
-    (insert "\n** GitHub — Dependabot Alerts (critical/high)  :security:\n")
+    (insert "\n** Dependabot Alerts (critical/high)  :security:\n")
     (daily-plan--insert-items .github_dependabot_alerts #'daily-plan--insert-dependabot nil)
 
     (insert "\n** Jira — CVEs / Security Issues  :security:\n")
@@ -176,27 +231,82 @@
     (insert "\n** GitHub — Review Requests  :review:\n")
     (daily-plan--insert-items .github_reviews #'daily-plan--insert-gh-item nil)))
 
+;; ── Render: weekly ──
+
 (defun daily-plan--render-weekly (data)
   "Render weekly DATA into current buffer."
   (let-alist data
     (insert (format "* Weekly Review — %s\n\n" .week))
 
+    ;; Org completed tasks
+    (when .org_done
+      (insert "** Completed Tasks (Org)  :done:\n")
+      ;; Group by section
+      (let ((by-section (make-hash-table :test 'equal))
+            (order '()))
+        (dolist (item .org_done)
+          (let ((section (or (alist-get 'section item) "(uncategorized)")))
+            (unless (gethash section by-section)
+              (push section order))
+            (push item (gethash section by-section))))
+        (dolist (section (nreverse order))
+          (insert (format "*** %s\n" section))
+          (dolist (item (nreverse (gethash section by-section)))
+            (daily-plan--insert-org-done-item item))))
+      (insert "\n"))
+
+    ;; AI sessions
+    (when .ai_sessions
+      (let ((filtered (seq-remove
+                       (lambda (item)
+                         (string-match-p "auto-recovered"
+                                         (downcase (or (alist-get 'title item) ""))))
+                       .ai_sessions)))
+        (when filtered
+          (insert (format "** AI Sessions (%d)  :ai:\n" (length filtered)))
+          (dolist (item filtered)
+            (daily-plan--insert-ai-item item))
+          (insert "\n"))))
+
+    ;; Jira completed
     (insert "** Completed (Jira)  :done:\n")
     (daily-plan--insert-items .jira_completed #'daily-plan--insert-jira-item "(nothing completed)")
 
-    (insert "\n** Completed (GitHub — Merged PRs)  :done:\n")
+    ;; GitHub merged
+    (insert "\n** Merged PRs  :done:\n")
     (daily-plan--insert-items .github_merged #'daily-plan--insert-gh-item "(no merged PRs)")
 
+    ;; Reviews given
+    (when .github_reviewed
+      (insert (format "\n** Reviews Given (%d)  :review:\n" (length .github_reviewed)))
+      (daily-plan--insert-items .github_reviewed #'daily-plan--insert-gh-item nil))
+
+    ;; Issues filed
+    (when .github_issues_created
+      (insert (format "\n** Issues Filed (%d)\n" (length .github_issues_created)))
+      (daily-plan--insert-items .github_issues_created #'daily-plan--insert-gh-item nil))
+
+    ;; Discussions
+    (when .github_discussions
+      (insert (format "\n** Discussions (%d)  :community:\n" (length .github_discussions)))
+      (daily-plan--insert-items .github_discussions #'daily-plan--insert-discussion-item nil))
+
+    ;; Comments
+    (when .github_comments
+      (insert (format "\n** Comments (%d)\n" (length .github_comments)))
+      (daily-plan--insert-items .github_comments #'daily-plan--insert-comment-item nil))
+
+    ;; Still in progress
     (insert "\n** Still In Progress\n")
     (daily-plan--insert-items .jira_in_progress #'daily-plan--insert-jira-item nil)
 
+    ;; Backlog
     (insert "\n** Backlog — Candidates for Next Week\n")
     (daily-plan--insert-items .jira_backlog #'daily-plan--insert-jira-item nil)
 
+    ;; Assigned issues
     (insert "\n** GitHub Issues (assigned)\n")
-    (daily-plan--insert-items .github_issues #'daily-plan--insert-gh-item nil)
-
-    (insert (format "\n/Schedule: daily-plan schedule SRVKP-1234 %s/\n" .next_monday))))
+    (daily-plan--insert-items .github_issues #'daily-plan--insert-gh-item nil)))
 
 ;; ── Buffer management ──
 
@@ -209,6 +319,9 @@
         (erase-buffer)
         (funcall render-fn data)
         (daily-plan-mode)
+        ;; Fold all sections to level 2 for overview
+        (goto-char (point-min))
+        (org-content 2)
         (goto-char (min pos (point-max)))))
     (pop-to-buffer buf)))
 
@@ -222,7 +335,9 @@
       (let ((inhibit-read-only t))
         (erase-buffer)
         (insert "Loading...")
-        (daily-plan-mode)))
+        (daily-plan-mode)
+        (setq-local daily-plan--current-args args)
+        (setq-local daily-plan--current-render-fn render-fn)))
     (pop-to-buffer buf)
     ;; Run async
     (make-process
@@ -241,6 +356,10 @@
                (if data
                    (progn
                      (daily-plan--create-buffer buf-name render-fn data)
+                     ;; Preserve local vars after re-render
+                     (with-current-buffer buf-name
+                       (setq-local daily-plan--current-args args)
+                       (setq-local daily-plan--current-render-fn render-fn))
                      (message "%s ready." buf-name))
                  (message "Failed to parse %s output" buf-name)))
            (message "daily-plan failed with exit code %d" (process-exit-status proc)))
@@ -269,6 +388,19 @@
   (interactive)
   (daily-plan--run-async "*daily-plan-weekly*" '("weekly") #'daily-plan--render-weekly))
 
+;;;###autoload
+(defun daily-plan-review (&optional period)
+  "Show full activity review for PERIOD.
+PERIOD can be \"this week\", \"last week\", \"this month\", etc."
+  (interactive
+   (list (completing-read "Period: "
+                          '("this week" "last week" "this month" "last month")
+                          nil nil nil nil "this week")))
+  (let* ((buf-name (format "*daily-plan-review [%s]*" period))
+         (args (list "review" period)))
+    (setq daily-plan--current-period period)
+    (daily-plan--run-async buf-name args #'daily-plan--render-weekly)))
+
 ;;;###autoload
 (defun daily-plan-schedule (key &optional date)
   "Schedule a Jira or GitHub issue KEY for DATE.
@@ -310,12 +442,41 @@ KEY should be PROJ-123 for Jira or owner/repo#123 for GitHub."
 (defun daily-plan-refresh ()
   "Refresh the current daily-plan buffer."
   (interactive)
-  (let ((buf-name (buffer-name)))
+  (let ((args daily-plan--current-args)
+        (render-fn daily-plan--current-render-fn)
+        (buf-name (buffer-name)))
     (cond
+     ;; Use stored args/render if available
+     ((and args render-fn)
+      (daily-plan--run-async buf-name args render-fn))
+     ;; Fallback by buffer name
      ((string= buf-name "*daily-plan*") (daily-plan-show))
      ((string= buf-name "*daily-plan-inbox*") (daily-plan-inbox))
      ((string= buf-name "*daily-plan-weekly*") (daily-plan-weekly))
      (t (message "Not a daily-plan buffer")))))
 
+(defun daily-plan-switch-period ()
+  "Switch the time period for review/weekly buffers."
+  (interactive)
+  (let ((period (completing-read "Period: "
+                                 '("this week" "last week" "this month" "last month")
+                                 nil nil nil nil (or daily-plan--current-period "this week"))))
+    (cond
+     ((string-match-p "review" (buffer-name))
+      (daily-plan-review period))
+     ((string-match-p "weekly" (buffer-name))
+      ;; Weekly always uses "this week", suggest review instead
+      (daily-plan-review period))
+     (t (daily-plan-review period)))))
+
+(defun daily-plan-yank-markdown ()
+  "Copy the current buffer content as markdown to the kill ring.
+Runs `daily-plan review` with the current period to get markdown."
+  (interactive)
+  (let* ((period (or daily-plan--current-period "this week"))
+         (output (daily-plan--run-plain "review" period)))
+    (kill-new output)
+    (message "Markdown copied to kill ring (%d chars)" (length output))))
+
 (provide 'daily-plan)
 ;;; daily-plan.el ends here

@@ -1,227 +0,0 @@
-// Package main provides the review-tool CLI.
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-	"github.com/vdemeester/home/tools/review-tool/internal/config"
-	"github.com/vdemeester/home/tools/review-tool/internal/filter"
-	"github.com/vdemeester/home/tools/review-tool/internal/output"
-	"github.com/vdemeester/home/tools/review-tool/internal/sources"
-	"github.com/vdemeester/home/tools/review-tool/internal/timerange"
-)
-
-var (
-	cfgFile        string
-	outputFormat   string
-	sourcesFlag    []string
-	includeFolders []string
-	excludeFolders []string
-)
-
-func main() {
-	if err := run(os.Args[1:]); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-func run(args []string) error {
-	// Parse flags
-	var timeRangeStr string
-	var showHelp bool
-
-	for i := 0; i < len(args); i++ {
-		arg := args[i]
-		switch {
-		case arg == "-h" || arg == "--help":
-			showHelp = true
-		case arg == "-c" || arg == "--config":
-			if i+1 < len(args) {
-				i++
-				cfgFile = args[i]
-			}
-		case arg == "-f" || arg == "--format":
-			if i+1 < len(args) {
-				i++
-				outputFormat = args[i]
-			}
-		case arg == "-s" || arg == "--source":
-			if i+1 < len(args) {
-				i++
-				sourcesFlag = append(sourcesFlag, args[i])
-			}
-		case arg == "-d" || arg == "--folder":
-			if i+1 < len(args) {
-				i++
-				includeFolders = append(includeFolders, args[i])
-			}
-		case arg == "-D" || arg == "--exclude-folder":
-			if i+1 < len(args) {
-				i++
-				excludeFolders = append(excludeFolders, args[i])
-			}
-		case arg == "config":
-			return runConfigCmd()
-		case arg == "sources":
-			return runSourcesCmd()
-		case arg[0] != '-':
-			timeRangeStr = arg
-		}
-	}
-
-	if showHelp {
-		printHelp()
-		return nil
-	}
-
-	return runReview(timeRangeStr)
-}
-
-func printHelp() {
-	fmt.Println(`review-tool - Generate activity review reports from multiple sources
-
-Usage:
-  review-tool [time-range] [flags]
-  review-tool [command]
-
-Commands:
-  config    Show current configuration
-  sources   List available data sources
-
-Arguments:
-  time-range  Natural language time range (default: "last week")
-              Examples: today, yesterday, "this week", "last week",
-                        "past 3 days", "this month", "2026-01-01..2026-01-15"
-
-Flags:
-  -c, --config string          Config file (default: ~/.config/review-tool/config.yaml)
-  -f, --format string          Output format: markdown, json, yaml/llm (default from config)
-  -s, --source string          Sources to include (can be repeated)
-  -d, --folder string          Include only items matching folder (can be repeated)
-  -D, --exclude-folder string  Exclude items matching folder (can be repeated)
-  -h, --help                   Show this help message
-
-Folder filtering:
-  Matches against project, repository, and directory metadata (substring,
-  case-insensitive). Parenthetical descriptions are stripped before matching.
-
-Examples:
-  review-tool                                          # Last week's activity
-  review-tool today                                    # Today's activity
-  review-tool "past 3 days"                            # Last 3 days
-  review-tool -f json "this week"                      # JSON output
-  review-tool -s github -s org                         # Only GitHub and org
-  review-tool -d tektoncd                              # Only tektoncd projects
-  review-tool -d tektoncd -d chisel                    # tektoncd OR chisel
-  review-tool -D home                                  # Exclude homelab
-  review-tool -d tektoncd -D tektoncd/plumbing         # tektoncd except plumbing`)
-}
-
-func runReview(timeRangeStr string) error {
-	// Load config
-	cfg, err := config.Load(cfgFile)
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	// Parse time range
-	if timeRangeStr == "" {
-		timeRangeStr = "last week"
-	}
-
-	tr, err := timerange.Parse(timeRangeStr)
-	if err != nil {
-		return fmt.Errorf("invalid time range: %w", err)
-	}
-
-	// Create source registry
-	registry := sources.NewRegistry(cfg)
-
-	// Fetch from sources
-	ctx := context.Background()
-	var activities map[string]*activity.Activity
-	if len(sourcesFlag) > 0 {
-		activities = registry.FetchSelected(ctx, tr.Start, tr.End, sourcesFlag)
-	} else {
-		activities = registry.FetchAll(ctx, tr.Start, tr.End)
-	}
-
-	// Apply folder filters
-	f := &filter.Filter{
-		IncludeFolders: includeFolders,
-		ExcludeFolders: excludeFolders,
-	}
-	f.Apply(activities)
-
-	// Build report
-	report := &activity.ReviewReport{
-		GeneratedAt: time.Now(),
-		TimeRange:   *tr,
-		Activities:  activities,
-	}
-
-	if cfg.Output.IncludeSummary {
-		report.CalculateSummary()
-	}
-
-	// Output
-	format := outputFormat
-	if format == "" {
-		format = cfg.Output.DefaultFormat
-	}
-
-	switch format {
-	case "json":
-		return output.WriteJSON(os.Stdout, report)
-	case "yaml", "llm":
-		return output.WriteYAML(os.Stdout, report)
-	default:
-		return output.WriteMarkdown(os.Stdout, report)
-	}
-}
-
-func runConfigCmd() error {
-	cfg, err := config.Load(cfgFile)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Config file: %s\n\n", config.DefaultConfigPath())
-	fmt.Printf("User: %s <%s>\n\n", cfg.User.Name, cfg.User.Email)
-
-	fmt.Println("Sources:")
-	fmt.Printf("  GitHub:  enabled=%v\n", cfg.GitHub.Enabled)
-	fmt.Printf("  Org:     enabled=%v, files=%d\n", cfg.Org.Enabled, len(cfg.Org.Files))
-	fmt.Printf("  Jira:    enabled=%v\n", cfg.Jira.Enabled)
-	fmt.Printf("  AI:      enabled=%v, dir=%s\n", cfg.AI.Enabled, cfg.AI.Dir)
-
-	fmt.Printf("\nOutput: format=%s, summary=%v\n", cfg.Output.DefaultFormat, cfg.Output.IncludeSummary)
-
-	return nil
-}
-
-func runSourcesCmd() error {
-	cfg, err := config.Load(cfgFile)
-	if err != nil {
-		return err
-	}
-
-	registry := sources.NewRegistry(cfg)
-
-	fmt.Println("Available sources:")
-	for _, name := range registry.Sources() {
-		source, _ := registry.Get(name)
-		status := "ok"
-		if err := source.Validate(); err != nil {
-			status = fmt.Sprintf("error: %v", err)
-		}
-		fmt.Printf("  %s: %s\n", name, status)
-	}
-
-	return nil
-}

@@ -1,73 +0,0 @@
-// Package activity defines the core types for activity tracking.
-package activity
-
-import "time"
-
-// Category represents the source category of an activity.
-type Category string
-
-const (
-	CategoryGitHub Category = "github"
-	CategoryOrg    Category = "org"
-	CategoryJira   Category = "jira"
-	CategoryAI     Category = "ai"
-)
-
-// ActivityItem represents a single unit of work or event.
-type ActivityItem struct {
-	ID          string            `json:"id"`
-	Title       string            `json:"title"`
-	Description string            `json:"description,omitempty"`
-	Category    Category          `json:"category"`
-	Type        string            `json:"type"` // e.g., "pr_merged", "todo_done", "issue_updated", "session"
-	Timestamp   time.Time         `json:"timestamp"`
-	URL         string            `json:"url,omitempty"`
-	Metadata    map[string]string `json:"metadata,omitempty"`
-}
-
-// Activity aggregates items from a single source.
-type Activity struct {
-	Source string         `json:"source"`
-	Items  []ActivityItem `json:"items"`
-	Error  string         `json:"error,omitempty"`
-}
-
-// TimeRange represents the query period.
-type TimeRange struct {
-	Start       time.Time `json:"start"`
-	End         time.Time `json:"end"`
-	Description string    `json:"description"` // e.g., "last week"
-}
-
-// Summary provides high-level metrics.
-type Summary struct {
-	TotalItems      int            `json:"total_items"`
-	ItemsByCategory map[string]int `json:"items_by_category"`
-	ItemsByType     map[string]int `json:"items_by_type"`
-}
-
-// ReviewReport is the complete output.
-type ReviewReport struct {
-	GeneratedAt time.Time            `json:"generated_at"`
-	TimeRange   TimeRange            `json:"time_range"`
-	Activities  map[string]*Activity `json:"activities"`
-	Summary     *Summary             `json:"summary,omitempty"`
-}
-
-// CalculateSummary computes summary statistics from activities.
-func (r *ReviewReport) CalculateSummary() {
-	summary := &Summary{
-		ItemsByCategory: make(map[string]int),
-		ItemsByType:     make(map[string]int),
-	}
-
-	for _, act := range r.Activities {
-		for _, item := range act.Items {
-			summary.TotalItems++
-			summary.ItemsByCategory[string(item.Category)]++
-			summary.ItemsByType[item.Type]++
-		}
-	}
-
-	r.Summary = summary
-}

@@ -1,173 +0,0 @@
-// Package config handles configuration loading and defaults.
-package config
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-)
-
-// Config represents the complete configuration.
-type Config struct {
-	User   UserConfig   `yaml:"user"`
-	GitHub GitHubConfig `yaml:"github"`
-	Org    OrgConfig    `yaml:"org"`
-	Jira   JiraConfig   `yaml:"jira"`
-	AI     AIConfig     `yaml:"ai"`
-	Output OutputConfig `yaml:"output"`
-}
-
-// UserConfig holds user identification.
-type UserConfig struct {
-	Name  string `yaml:"name"`
-	Email string `yaml:"email"`
-}
-
-// GitHubConfig configures the GitHub source.
-type GitHubConfig struct {
-	Enabled            bool     `yaml:"enabled"`
-	Username           string   `yaml:"username"`
-	Repos              []string `yaml:"repos,omitempty"`
-	IncludePRs         bool     `yaml:"include_prs"`
-	IncludeIssues      bool     `yaml:"include_issues"`
-	IncludeReviews     bool     `yaml:"include_reviews"`
-	IncludeCommits     bool     `yaml:"include_commits"`
-	IncludeDiscussions bool     `yaml:"include_discussions"`
-	IncludeComments    bool     `yaml:"include_comments"`
-}
-
-// OrgConfig configures the org-mode source.
-type OrgConfig struct {
-	Enabled             bool     `yaml:"enabled"`
-	Files               []string `yaml:"files"`
-	ArchiveDir          string   `yaml:"archive_dir,omitempty"` // Optional archive directory to scan
-	IncludeDone         bool     `yaml:"include_done"`
-	IncludeStateChanges bool     `yaml:"include_state_changes"`
-	IncludeClockEntries bool     `yaml:"include_clock_entries"`
-}
-
-// JiraConfig configures the Jira source.
-type JiraConfig struct {
-	Enabled  bool     `yaml:"enabled"`
-	Server   string   `yaml:"server"`
-	Projects []string `yaml:"projects,omitempty"`
-	Username string   `yaml:"username"`
-}
-
-// AIConfig configures the AI session history source (~/.local/share/ai).
-type AIConfig struct {
-	Enabled          bool   `yaml:"enabled"`
-	Dir              string `yaml:"dir"`
-	IncludeSessions  bool   `yaml:"include_sessions"`
-	IncludeLearnings bool   `yaml:"include_learnings"`
-	IncludeResearch  bool   `yaml:"include_research"`
-	IncludePlans     bool   `yaml:"include_plans"`
-}
-
-// OutputConfig configures output formatting.
-type OutputConfig struct {
-	DefaultFormat  string `yaml:"default_format"`
-	IncludeSummary bool   `yaml:"include_summary"`
-}
-
-// DefaultConfigPath returns the default config file location.
-func DefaultConfigPath() string {
-	home, _ := os.UserHomeDir()
-	return filepath.Join(home, ".config", "review-tool", "config.yaml")
-}
-
-// Load reads configuration from file, falling back to defaults.
-func Load(path string) (*Config, error) {
-	if path == "" {
-		path = DefaultConfigPath()
-	}
-
-	cfg := DefaultConfig()
-
-	data, err := os.ReadFile(path)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return cfg, nil // Use defaults if no config file
-		}
-		return nil, err
-	}
-
-	if err := yaml.Unmarshal(data, cfg); err != nil {
-		return nil, err
-	}
-
-	// Expand ~ in paths
-	cfg.expandPaths()
-
-	return cfg, nil
-}
-
-// DefaultConfig returns a configuration with sensible defaults.
-func DefaultConfig() *Config {
-	home, _ := os.UserHomeDir()
-
-	return &Config{
-		User: UserConfig{},
-		GitHub: GitHubConfig{
-			Enabled:            true,
-			IncludePRs:         true,
-			IncludeIssues:      true,
-			IncludeReviews:     true,
-			IncludeCommits:     false,
-			IncludeDiscussions: true,
-			IncludeComments:    true,
-		},
-		Org: OrgConfig{
-			Enabled: true,
-			Files: []string{
-				filepath.Join(home, "desktop", "org", "todos.org"),
-			},
-			ArchiveDir:          filepath.Join(home, "desktop", "org", "archive"),
-			IncludeDone:         true,
-			IncludeStateChanges: true,
-			IncludeClockEntries: true,
-		},
-		Jira: JiraConfig{
-			Enabled: false,
-		},
-		AI: AIConfig{
-			Enabled:          true,
-			Dir:              filepath.Join(home, ".local", "share", "ai"),
-			IncludeSessions:  true,
-			IncludeLearnings: true,
-			IncludeResearch:  true,
-			IncludePlans:     true,
-		},
-		Output: OutputConfig{
-			DefaultFormat:  "markdown",
-			IncludeSummary: true,
-		},
-	}
-}
-
-func (c *Config) expandPaths() {
-	home, _ := os.UserHomeDir()
-
-	// Expand org files
-	for i, f := range c.Org.Files {
-		c.Org.Files[i] = expandHome(f, home)
-	}
-
-	// Expand org archive dir
-	c.Org.ArchiveDir = expandHome(c.Org.ArchiveDir, home)
-
-	// Expand AI dir
-	c.AI.Dir = expandHome(c.AI.Dir, home)
-}
-
-func expandHome(path, home string) string {
-	if strings.HasPrefix(path, "~/") {
-		return filepath.Join(home, path[2:])
-	}
-	if path == "~" {
-		return home
-	}
-	return path
-}

@@ -1,124 +0,0 @@
-// Package filter provides post-fetch activity filtering.
-package filter
-
-import (
-	"strings"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-)
-
-// Filter defines include/exclude rules for activity items.
-type Filter struct {
-	// IncludeFolders keeps only items whose project/repository/directory
-	// matches one of these values (substring, case-insensitive).
-	// Empty means no include constraint.
-	IncludeFolders []string
-	// ExcludeFolders removes items whose project/repository/directory
-	// matches any of these values (substring, case-insensitive).
-	ExcludeFolders []string
-}
-
-// IsEmpty returns true if no filters are configured.
-func (f *Filter) IsEmpty() bool {
-	return len(f.IncludeFolders) == 0 && len(f.ExcludeFolders) == 0
-}
-
-// Apply filters a map of activities in place, removing non-matching items.
-func (f *Filter) Apply(activities map[string]*activity.Activity) {
-	if f.IsEmpty() {
-		return
-	}
-	for name, act := range activities {
-		activities[name] = &activity.Activity{
-			Source: act.Source,
-			Items:  f.FilterItems(act.Items),
-			Error:  act.Error,
-		}
-	}
-}
-
-// FilterItems returns only the items that pass the filter.
-func (f *Filter) FilterItems(items []activity.ActivityItem) []activity.ActivityItem {
-	if f.IsEmpty() {
-		return items
-	}
-	var result []activity.ActivityItem
-	for _, item := range items {
-		if f.Match(item) {
-			result = append(result, item)
-		}
-	}
-	return result
-}
-
-// Match returns true if an item passes the filter.
-func (f *Filter) Match(item activity.ActivityItem) bool {
-	folders := itemFolders(item)
-
-	// Items with no folder metadata (e.g. Jira issues) pass through
-	// exclude filters (they can't match) but are dropped by include
-	// filters (they can't satisfy the constraint).
-	if len(folders) == 0 {
-		return len(f.IncludeFolders) == 0
-	}
-
-	// Exclude check: if any folder matches an exclude pattern, reject
-	if len(f.ExcludeFolders) > 0 && matchesAny(folders, f.ExcludeFolders) {
-		return false
-	}
-
-	// Include check: at least one folder must match an include pattern
-	if len(f.IncludeFolders) > 0 {
-		return matchesAny(folders, f.IncludeFolders)
-	}
-
-	return true
-}
-
-// itemFolders extracts all folder-like values from an item's metadata.
-// It looks at project, repository, and directory fields.
-func itemFolders(item activity.ActivityItem) []string {
-	var folders []string
-	for _, key := range []string{"project", "repository", "directory"} {
-		if val, ok := item.Metadata[key]; ok && val != "" {
-			folders = append(folders, normalizePath(val))
-		}
-	}
-	return folders
-}
-
-// matchesAny returns true if any folder matches any pattern.
-// Matching is substring-based and case-insensitive.
-func matchesAny(folders []string, patterns []string) bool {
-	for _, folder := range folders {
-		for _, pattern := range patterns {
-			if containsFold(folder, normalizePath(pattern)) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// normalizePath cleans a path for matching:
-// - strips trailing descriptions in parens: "~/src/home (homelab)" → "~/src/home"
-// - strips trailing whitespace
-// - strips trailing slashes
-func normalizePath(path string) string {
-	path = strings.TrimSpace(path)
-
-	// Strip parenthetical suffix: "~/src/home (homelab monorepo)" → "~/src/home"
-	if idx := strings.Index(path, " ("); idx > 0 {
-		path = path[:idx]
-	}
-
-	// Strip trailing slashes
-	path = strings.TrimRight(path, "/")
-
-	return path
-}
-
-// containsFold is a case-insensitive substring check.
-func containsFold(s, substr string) bool {
-	return strings.Contains(strings.ToLower(s), strings.ToLower(substr))
-}

@@ -1,177 +0,0 @@
-package filter
-
-import (
-	"testing"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-)
-
-func item(meta map[string]string) activity.ActivityItem {
-	return activity.ActivityItem{
-		Title:    "test",
-		Metadata: meta,
-	}
-}
-
-func TestFilter_IncludeFolder(t *testing.T) {
-	f := &Filter{IncludeFolders: []string{"tektoncd"}}
-
-	tests := []struct {
-		name  string
-		item  activity.ActivityItem
-		match bool
-	}{
-		{"exact repo match", item(map[string]string{"repository": "tektoncd/pipeline"}), true},
-		{"project match", item(map[string]string{"project": "tektoncd/plumbing"}), true},
-		{"directory match", item(map[string]string{"directory": "~/src/tektoncd/pipeline"}), true},
-		{"no match", item(map[string]string{"project": "~/src/home"}), false},
-		{"no metadata", item(map[string]string{}), false},
-		{"case insensitive", item(map[string]string{"project": "TektonCD/Pipeline"}), true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := f.Match(tt.item); got != tt.match {
-				t.Errorf("Match() = %v, want %v", got, tt.match)
-			}
-		})
-	}
-}
-
-func TestFilter_ExcludeFolder(t *testing.T) {
-	f := &Filter{ExcludeFolders: []string{"home"}}
-
-	tests := []struct {
-		name  string
-		item  activity.ActivityItem
-		match bool
-	}{
-		{"excludes home project", item(map[string]string{"project": "~/src/home (homelab)"}), false},
-		{"excludes home dir", item(map[string]string{"directory": "~/src/home"}), false},
-		{"keeps tektoncd", item(map[string]string{"project": "tektoncd/pipeline"}), true},
-		{"no metadata passes through", item(map[string]string{}), true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := f.Match(tt.item); got != tt.match {
-				t.Errorf("Match() = %v, want %v", got, tt.match)
-			}
-		})
-	}
-}
-
-func TestFilter_IncludeAndExclude(t *testing.T) {
-	// Include tektoncd but exclude tektoncd/plumbing
-	f := &Filter{
-		IncludeFolders: []string{"tektoncd"},
-		ExcludeFolders: []string{"tektoncd/plumbing"},
-	}
-
-	tests := []struct {
-		name  string
-		item  activity.ActivityItem
-		match bool
-	}{
-		{"includes pipeline", item(map[string]string{"project": "tektoncd/pipeline"}), true},
-		{"excludes plumbing", item(map[string]string{"project": "tektoncd/plumbing"}), false},
-		{"excludes non-tektoncd", item(map[string]string{"project": "~/src/home"}), false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := f.Match(tt.item); got != tt.match {
-				t.Errorf("Match() = %v, want %v", got, tt.match)
-			}
-		})
-	}
-}
-
-func TestFilter_NormalizePath(t *testing.T) {
-	tests := []struct {
-		input string
-		want  string
-	}{
-		{"~/src/home (homelab)", "~/src/home"},
-		{"~/src/home (homelab monorepo)", "~/src/home"},
-		{"tektoncd/pipeline", "tektoncd/pipeline"},
-		{"  ~/src/home/  ", "~/src/home"},
-		{"home", "home"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			if got := normalizePath(tt.input); got != tt.want {
-				t.Errorf("normalizePath(%q) = %q, want %q", tt.input, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestFilter_Apply(t *testing.T) {
-	f := &Filter{IncludeFolders: []string{"tektoncd"}}
-
-	activities := map[string]*activity.Activity{
-		"ai": {
-			Source: "ai",
-			Items: []activity.ActivityItem{
-				item(map[string]string{"project": "tektoncd/pipeline"}),
-				item(map[string]string{"project": "~/src/home"}),
-				item(map[string]string{"project": "tektoncd/plumbing"}),
-			},
-		},
-		"github": {
-			Source: "github",
-			Items: []activity.ActivityItem{
-				item(map[string]string{"repository": "tektoncd/pipeline"}),
-				item(map[string]string{"repository": "vdemeester/home"}),
-			},
-		},
-	}
-
-	f.Apply(activities)
-
-	if len(activities["ai"].Items) != 2 {
-		t.Errorf("ai items = %d, want 2", len(activities["ai"].Items))
-	}
-	if len(activities["github"].Items) != 1 {
-		t.Errorf("github items = %d, want 1", len(activities["github"].Items))
-	}
-}
-
-func TestFilter_Empty(t *testing.T) {
-	f := &Filter{}
-
-	if !f.IsEmpty() {
-		t.Error("expected empty filter")
-	}
-
-	// Empty filter should pass everything
-	i := item(map[string]string{"project": "anything"})
-	if !f.Match(i) {
-		t.Error("empty filter should match everything")
-	}
-}
-
-func TestFilter_MultipleIncludeFolders(t *testing.T) {
-	// Either tektoncd or chisel
-	f := &Filter{IncludeFolders: []string{"tektoncd", "chisel"}}
-
-	tests := []struct {
-		name  string
-		item  activity.ActivityItem
-		match bool
-	}{
-		{"tektoncd matches", item(map[string]string{"project": "tektoncd/pipeline"}), true},
-		{"chisel matches", item(map[string]string{"project": "github.com/vdemeester/chisel"}), true},
-		{"home excluded", item(map[string]string{"project": "~/src/home"}), false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := f.Match(tt.item); got != tt.match {
-				t.Errorf("Match() = %v, want %v", got, tt.match)
-			}
-		})
-	}
-}

@@ -1,15 +0,0 @@
-package output
-
-import (
-	"encoding/json"
-	"io"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-)
-
-// WriteJSON writes the report in JSON format.
-func WriteJSON(w io.Writer, report *activity.ReviewReport) error {
-	encoder := json.NewEncoder(w)
-	encoder.SetIndent("", "  ")
-	return encoder.Encode(report)
-}

@@ -1,76 +0,0 @@
-package output
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-	"time"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-)
-
-func TestWriteJSON_ValidOutput(t *testing.T) {
-	report := &activity.ReviewReport{
-		GeneratedAt: time.Date(2026, 1, 27, 15, 30, 0, 0, time.UTC),
-		TimeRange: activity.TimeRange{
-			Start:       time.Date(2026, 1, 20, 0, 0, 0, 0, time.UTC),
-			End:         time.Date(2026, 1, 27, 0, 0, 0, 0, time.UTC),
-			Description: "last week",
-		},
-		Activities: map[string]*activity.Activity{
-			"github": {
-				Source: "github",
-				Items: []activity.ActivityItem{
-					{
-						ID:       "1",
-						Title:    "Test PR",
-						Type:     "pr_merged",
-						Category: activity.CategoryGitHub,
-					},
-				},
-			},
-		},
-	}
-
-	var buf bytes.Buffer
-	err := WriteJSON(&buf, report)
-	if err != nil {
-		t.Fatalf("WriteJSON() error = %v", err)
-	}
-
-	// Verify it's valid JSON
-	var parsed activity.ReviewReport
-	if err := json.Unmarshal(buf.Bytes(), &parsed); err != nil {
-		t.Fatalf("output is not valid JSON: %v", err)
-	}
-
-	if parsed.TimeRange.Description != "last week" {
-		t.Errorf("parsed description = %q, want %q", parsed.TimeRange.Description, "last week")
-	}
-
-	if len(parsed.Activities["github"].Items) != 1 {
-		t.Errorf("parsed activities count = %d, want 1", len(parsed.Activities["github"].Items))
-	}
-}
-
-func TestWriteJSON_Indented(t *testing.T) {
-	report := &activity.ReviewReport{
-		GeneratedAt: time.Now(),
-		TimeRange: activity.TimeRange{
-			Description: "today",
-		},
-		Activities: make(map[string]*activity.Activity),
-	}
-
-	var buf bytes.Buffer
-	err := WriteJSON(&buf, report)
-	if err != nil {
-		t.Fatalf("WriteJSON() error = %v", err)
-	}
-
-	// Check that output is indented (contains newlines and spaces)
-	output := buf.String()
-	if !bytes.Contains(buf.Bytes(), []byte("\n  ")) {
-		t.Errorf("output should be indented, got:\n%s", output)
-	}
-}

@@ -1,156 +0,0 @@
-// Package output provides report formatting.
-package output
-
-import (
-	"fmt"
-	"io"
-	"sort"
-	"strings"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-)
-
-// WriteMarkdown writes the report in markdown format.
-func WriteMarkdown(w io.Writer, report *activity.ReviewReport) error {
-	fmt.Fprintf(w, "# Activity Review: %s\n\n", report.TimeRange.Description)
-	fmt.Fprintf(w, "**Period:** %s to %s\n",
-		report.TimeRange.Start.Format("2006-01-02"),
-		report.TimeRange.End.Format("2006-01-02"))
-	fmt.Fprintf(w, "**Generated:** %s\n\n", report.GeneratedAt.Format("2006-01-02 15:04"))
-
-	// Summary section
-	if report.Summary != nil && report.Summary.TotalItems > 0 {
-		fmt.Fprintln(w, "## Summary")
-		fmt.Fprintf(w, "- **Total activities:** %d\n", report.Summary.TotalItems)
-
-		// Sort categories for consistent output
-		cats := make([]string, 0, len(report.Summary.ItemsByCategory))
-		for cat := range report.Summary.ItemsByCategory {
-			cats = append(cats, cat)
-		}
-		sort.Strings(cats)
-
-		for _, cat := range cats {
-			fmt.Fprintf(w, "- **%s:** %d\n", strings.Title(cat), report.Summary.ItemsByCategory[cat])
-		}
-		fmt.Fprintln(w)
-	}
-
-	// Activities by source
-	sourceOrder := []string{"github", "org", "jira", "ai"}
-	for _, source := range sourceOrder {
-		act, ok := report.Activities[source]
-		if !ok || len(act.Items) == 0 {
-			continue
-		}
-
-		fmt.Fprintf(w, "## %s\n\n", formatSourceName(source))
-
-		if act.Error != "" {
-			fmt.Fprintf(w, "> Error: %s\n\n", act.Error)
-			continue
-		}
-
-		// Group by type
-		byType := groupByType(act.Items)
-		types := make([]string, 0, len(byType))
-		for t := range byType {
-			types = append(types, t)
-		}
-		sort.Strings(types)
-
-		for _, typ := range types {
-			items := byType[typ]
-			fmt.Fprintf(w, "### %s (%d)\n\n", formatTypeName(typ), len(items))
-
-			// Sort by timestamp descending
-			sort.Slice(items, func(i, j int) bool {
-				return items[i].Timestamp.After(items[j].Timestamp)
-			})
-
-			for _, item := range items {
-				writeMarkdownItem(w, item)
-			}
-			fmt.Fprintln(w)
-		}
-	}
-
-	return nil
-}
-
-func writeMarkdownItem(w io.Writer, item activity.ActivityItem) {
-	timestamp := item.Timestamp.Format("2006-01-02 15:04")
-	if item.URL != "" {
-		fmt.Fprintf(w, "- [%s](%s) (%s)\n", item.Title, item.URL, timestamp)
-	} else {
-		fmt.Fprintf(w, "- %s (%s)\n", item.Title, timestamp)
-	}
-
-	// Show metadata for org items
-	if item.Category == activity.CategoryOrg {
-		var meta []string
-		if section := item.Metadata["section"]; section != "" {
-			meta = append(meta, section)
-		}
-		if file := item.Metadata["file"]; file != "" && !strings.HasSuffix(file, "todos.org") {
-			// Show shortened file path for archive items
-			if strings.Contains(file, "/archive/") {
-				parts := strings.Split(file, "/archive/")
-				if len(parts) > 1 {
-					meta = append(meta, "archive/"+parts[1])
-				}
-			}
-		}
-		if len(meta) > 0 {
-			fmt.Fprintf(w, "  _(%s)_\n", strings.Join(meta, " | "))
-		}
-	}
-
-	if item.Description != "" {
-		fmt.Fprintf(w, "  > %s\n", item.Description)
-	}
-}
-
-func groupByType(items []activity.ActivityItem) map[string][]activity.ActivityItem {
-	result := make(map[string][]activity.ActivityItem)
-	for _, item := range items {
-		result[item.Type] = append(result[item.Type], item)
-	}
-	return result
-}
-
-func formatSourceName(source string) string {
-	names := map[string]string{
-		"github": "GitHub",
-		"org":    "Org-mode",
-		"jira":   "Jira",
-		"ai":     "AI Sessions",
-	}
-	if name, ok := names[source]; ok {
-		return name
-	}
-	return strings.Title(source)
-}
-
-func formatTypeName(typ string) string {
-	names := map[string]string{
-		"pr_merged":          "PRs Merged",
-		"pr_reviewed":        "PRs Reviewed",
-		"issue_created":      "Issues Created",
-		"issue_closed":       "Issues Closed",
-		"issue_updated":      "Issues Updated",
-		"comment":            "Comments",
-		"discussion":         "Discussions Started",
-		"discussion_comment": "Discussion Comments",
-		"todo_done":          "Tasks Completed",
-		"state_change":       "State Changes",
-		"clock_entry":        "Time Logged",
-		"session":            "Sessions",
-		"learning":           "Learnings",
-		"research":           "Research",
-	}
-	if name, ok := names[typ]; ok {
-		return name
-	}
-	return strings.Title(strings.ReplaceAll(typ, "_", " "))
-}

@@ -1,153 +0,0 @@
-package output
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-)
-
-func TestWriteMarkdown_Header(t *testing.T) {
-	report := &activity.ReviewReport{
-		GeneratedAt: time.Date(2026, 1, 27, 15, 30, 0, 0, time.UTC),
-		TimeRange: activity.TimeRange{
-			Start:       time.Date(2026, 1, 20, 0, 0, 0, 0, time.UTC),
-			End:         time.Date(2026, 1, 27, 0, 0, 0, 0, time.UTC),
-			Description: "last week",
-		},
-		Activities: make(map[string]*activity.Activity),
-	}
-
-	var buf bytes.Buffer
-	err := WriteMarkdown(&buf, report)
-	if err != nil {
-		t.Fatalf("WriteMarkdown() error = %v", err)
-	}
-
-	output := buf.String()
-	if !strings.Contains(output, "# Activity Review: last week") {
-		t.Errorf("missing title header, got:\n%s", output)
-	}
-	if !strings.Contains(output, "**Period:** 2026-01-20 to 2026-01-27") {
-		t.Errorf("missing period, got:\n%s", output)
-	}
-}
-
-func TestWriteMarkdown_WithSummary(t *testing.T) {
-	report := &activity.ReviewReport{
-		GeneratedAt: time.Now(),
-		TimeRange: activity.TimeRange{
-			Start:       time.Now().AddDate(0, 0, -7),
-			End:         time.Now(),
-			Description: "last week",
-		},
-		Activities: make(map[string]*activity.Activity),
-		Summary: &activity.Summary{
-			TotalItems:      5,
-			ItemsByCategory: map[string]int{"github": 3, "org": 2},
-			ItemsByType:     map[string]int{"pr_merged": 3, "todo_done": 2},
-		},
-	}
-
-	var buf bytes.Buffer
-	err := WriteMarkdown(&buf, report)
-	if err != nil {
-		t.Fatalf("WriteMarkdown() error = %v", err)
-	}
-
-	output := buf.String()
-	if !strings.Contains(output, "## Summary") {
-		t.Errorf("missing summary section, got:\n%s", output)
-	}
-	if !strings.Contains(output, "**Total activities:** 5") {
-		t.Errorf("missing total count, got:\n%s", output)
-	}
-}
-
-func TestWriteMarkdown_WithActivities(t *testing.T) {
-	report := &activity.ReviewReport{
-		GeneratedAt: time.Now(),
-		TimeRange: activity.TimeRange{
-			Start:       time.Now().AddDate(0, 0, -7),
-			End:         time.Now(),
-			Description: "last week",
-		},
-		Activities: map[string]*activity.Activity{
-			"github": {
-				Source: "github",
-				Items: []activity.ActivityItem{
-					{
-						ID:        "1",
-						Title:     "Fix authentication bug",
-						Type:      "pr_merged",
-						Category:  activity.CategoryGitHub,
-						Timestamp: time.Now(),
-						URL:       "https://github.com/org/repo/pull/123",
-					},
-				},
-			},
-		},
-	}
-
-	var buf bytes.Buffer
-	err := WriteMarkdown(&buf, report)
-	if err != nil {
-		t.Fatalf("WriteMarkdown() error = %v", err)
-	}
-
-	output := buf.String()
-	if !strings.Contains(output, "## GitHub") {
-		t.Errorf("missing GitHub section, got:\n%s", output)
-	}
-	if !strings.Contains(output, "Fix authentication bug") {
-		t.Errorf("missing activity item, got:\n%s", output)
-	}
-	if !strings.Contains(output, "https://github.com/org/repo/pull/123") {
-		t.Errorf("missing URL, got:\n%s", output)
-	}
-}
-
-func TestFormatSourceName(t *testing.T) {
-	tests := []struct {
-		source string
-		want   string
-	}{
-		{"github", "GitHub"},
-		{"org", "Org-mode"},
-		{"jira", "Jira"},
-		{"ai", "AI Sessions"},
-		{"unknown", "Unknown"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.source, func(t *testing.T) {
-			got := formatSourceName(tt.source)
-			if got != tt.want {
-				t.Errorf("formatSourceName(%q) = %q, want %q", tt.source, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestFormatTypeName(t *testing.T) {
-	tests := []struct {
-		typ  string
-		want string
-	}{
-		{"pr_merged", "PRs Merged"},
-		{"todo_done", "Tasks Completed"},
-		{"session", "Sessions"},
-		{"custom_type", "Custom Type"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.typ, func(t *testing.T) {
-			got := formatTypeName(tt.typ)
-			if got != tt.want {
-				t.Errorf("formatTypeName(%q) = %q, want %q", tt.typ, got, tt.want)
-			}
-		})
-	}
-}

@@ -1,123 +0,0 @@
-package output
-
-import (
-	"fmt"
-	"io"
-	"sort"
-	"strings"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-)
-
-// WriteYAML writes the report in YAML format optimized for LLM consumption.
-// YAML format provides better accuracy for LLM understanding compared to JSON or XML.
-func WriteYAML(w io.Writer, report *activity.ReviewReport) error {
-	fmt.Fprintf(w, "# Activity Review: %s\n", report.TimeRange.Description)
-	fmt.Fprintf(w, "period:\n")
-	fmt.Fprintf(w, "  start: %s\n", report.TimeRange.Start.Format("2006-01-02"))
-	fmt.Fprintf(w, "  end: %s\n", report.TimeRange.End.Format("2006-01-02"))
-	fmt.Fprintf(w, "generated: %s\n", report.GeneratedAt.Format("2006-01-02 15:04"))
-	fmt.Fprintln(w)
-
-	// Summary
-	if report.Summary != nil && report.Summary.TotalItems > 0 {
-		fmt.Fprintln(w, "summary:")
-		fmt.Fprintf(w, "  total_activities: %d\n", report.Summary.TotalItems)
-
-		cats := make([]string, 0, len(report.Summary.ItemsByCategory))
-		for cat := range report.Summary.ItemsByCategory {
-			cats = append(cats, cat)
-		}
-		sort.Strings(cats)
-
-		fmt.Fprintln(w, "  by_category:")
-		for _, cat := range cats {
-			fmt.Fprintf(w, "    %s: %d\n", cat, report.Summary.ItemsByCategory[cat])
-		}
-		fmt.Fprintln(w)
-	}
-
-	// Activities by source
-	fmt.Fprintln(w, "activities:")
-	sourceOrder := []string{"github", "org", "jira", "ai"}
-	for _, source := range sourceOrder {
-		act, ok := report.Activities[source]
-		if !ok || len(act.Items) == 0 {
-			continue
-		}
-
-		fmt.Fprintf(w, "  %s:\n", source)
-
-		if act.Error != "" {
-			fmt.Fprintf(w, "    error: %q\n", act.Error)
-			continue
-		}
-
-		// Group by type
-		byType := groupByType(act.Items)
-		types := make([]string, 0, len(byType))
-		for t := range byType {
-			types = append(types, t)
-		}
-		sort.Strings(types)
-
-		for _, typ := range types {
-			items := byType[typ]
-			fmt.Fprintf(w, "    %s:\n", typ)
-
-			// Sort by timestamp descending
-			sort.Slice(items, func(i, j int) bool {
-				return items[i].Timestamp.After(items[j].Timestamp)
-			})
-
-			for _, item := range items {
-				writeYAMLItem(w, item)
-			}
-		}
-	}
-
-	return nil
-}
-
-func writeYAMLItem(w io.Writer, item activity.ActivityItem) {
-	// Escape title for YAML if needed
-	title := item.Title
-	if strings.ContainsAny(title, ":\n\"'") {
-		title = fmt.Sprintf("%q", title)
-	}
-
-	fmt.Fprintf(w, "      - title: %s\n", title)
-	fmt.Fprintf(w, "        timestamp: %s\n", item.Timestamp.Format("2006-01-02 15:04"))
-
-	if item.URL != "" {
-		fmt.Fprintf(w, "        url: %s\n", item.URL)
-	}
-
-	// Include relevant metadata
-	if section := item.Metadata["section"]; section != "" {
-		fmt.Fprintf(w, "        section: %s\n", section)
-	}
-	if file := item.Metadata["file"]; file != "" {
-		// Shorten archive paths
-		if strings.Contains(file, "/archive/") {
-			parts := strings.Split(file, "/archive/")
-			if len(parts) > 1 {
-				fmt.Fprintf(w, "        source: archive/%s\n", parts[1])
-			}
-		}
-	}
-	if duration := item.Metadata["duration"]; duration != "" {
-		fmt.Fprintf(w, "        duration: %s\n", duration)
-	}
-	if repo := item.Metadata["repo"]; repo != "" {
-		fmt.Fprintf(w, "        repo: %s\n", repo)
-	}
-
-	if item.Description != "" {
-		desc := item.Description
-		if strings.ContainsAny(desc, ":\n\"'") {
-			desc = fmt.Sprintf("%q", desc)
-		}
-		fmt.Fprintf(w, "        description: %s\n", desc)
-	}
-}

@@ -1,280 +0,0 @@
-package sources
-
-import (
-	"bufio"
-	"context"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"time"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/activity"
-	"github.com/vdemeester/home/tools/review-tool/internal/config"
-)
-
-var (
-	// **Date:** 2026-01-21
-	mdDateRe = regexp.MustCompile(`\*\*Date:\*\*\s+(\d{4}-\d{2}-\d{2})`)
-	// # Title or # Some Title Here
-	mdTitleRe = regexp.MustCompile(`^#\s+(.+)$`)
-	// #+title: SelfCI Analysis
-	orgTitleRe = regexp.MustCompile(`^\s*#\+title:\s*(.+)$`)
-	// #+date: [2026-01-16 Thu]
-	orgDateRe = regexp.MustCompile(`^\s*#\+date:\s*\[(\d{4}-\d{2}-\d{2})[^\]]*\]`)
-	// Filename patterns: 2026-01-21-something.md or 20260121-something.md
-	filenameDateRe        = regexp.MustCompile(`^(\d{4}-\d{2}-\d{2})`)
-	filenameDateCompactRe = regexp.MustCompile(`^(\d{8})`)
-	// **Key:** value or **Key**: value (with optional trailing **)
-	// Captures key and value from markdown bold metadata lines
-	mdMetadataRe = regexp.MustCompile(`^\*\*([A-Za-z][A-Za-z ]*?)\*?\*?:\*?\*?\s*(.+)$`)
-)
-
-// AISource fetches activity from AI session history (~/.local/share/ai).
-type AISource struct {
-	cfg *config.AIConfig
-}
-
-// NewAISource creates a new AI history source.
-func NewAISource(cfg *config.AIConfig) *AISource {
-	return &AISource{cfg: cfg}
-}
-
-// Name returns the source identifier.
-func (s *AISource) Name() string {
-	return "ai"
-}
-
-// Validate checks if the base directory exists.
-func (s *AISource) Validate() error {
-	if _, err := os.Stat(s.cfg.Dir); err != nil {
-		return err
-	}
-	return nil
-}
-
-// Fetch retrieves AI session activities within the time range.
-func (s *AISource) Fetch(ctx context.Context, start, end time.Time) (*activity.Activity, error) {
-	act := &activity.Activity{
-		Source: "ai",
-		Items:  []activity.ActivityItem{},
-	}
-
-	if s.cfg.IncludeSessions {
-		items, err := s.scanDirectory(filepath.Join(s.cfg.Dir, "sessions"), "session", start, end)
-		if err == nil {
-			act.Items = append(act.Items, items...)
-		}
-	}
-
-	if s.cfg.IncludeLearnings {
-		items, err := s.scanDirectory(filepath.Join(s.cfg.Dir, "learnings"), "learning", start, end)
-		if err == nil {
-			act.Items = append(act.Items, items...)
-		}
-	}
-
-	if s.cfg.IncludeResearch {
-		items, err := s.scanDirectory(filepath.Join(s.cfg.Dir, "research"), "research", start, end)
-		if err == nil {
-			act.Items = append(act.Items, items...)
-		}
-	}
-
-	if s.cfg.IncludePlans {
-		items, err := s.scanDirectory(filepath.Join(s.cfg.Dir, "plans"), "plan", start, end)
-		if err == nil {
-			act.Items = append(act.Items, items...)
-		}
-	}
-
-	return act, nil
-}
-
-func (s *AISource) scanDirectory(baseDir, itemType string, start, end time.Time) ([]activity.ActivityItem, error) {
-	var items []activity.ActivityItem
-
-	// Resolve symlinks so filepath.Walk can traverse symlinked directories
-	// (e.g. home-manager managed paths via nix store)
-	resolvedDir, err := filepath.EvalSymlinks(baseDir)
-	if err != nil {
-		resolvedDir = baseDir // Fall back to original if resolution fails
-	}
-
-	// Walk through YYYY-MM subdirectories
-	err = filepath.Walk(resolvedDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return nil // Skip errors, continue walking
-		}
-
-		if info.IsDir() {
-			return nil
-		}
-
-		// Only process .md and .org files
-		ext := strings.ToLower(filepath.Ext(path))
-		if ext != ".md" && ext != ".org" {
-			return nil
-		}
-
-		// Skip small files (likely not content files)
-		if info.Size() < 50 {
-			return nil
-		}
-
-		item, err := s.parseFile(path, itemType, ext, info.ModTime())
-		if err != nil {
-			return nil // Skip files that fail to parse
-		}
-
-		// Filter by date range
-		if item.Timestamp.Before(start) || item.Timestamp.After(end) {
-			return nil
-		}
-
-		items = append(items, *item)
-		return nil
-	})
-
-	return items, err
-}
-
-func (s *AISource) parseFile(path, itemType, ext string, modTime time.Time) (*activity.ActivityItem, error) {
-	file, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	var title string
-	var dateStr string
-	metadata := map[string]string{"path": path}
-	filename := filepath.Base(path)
-
-	scanner := bufio.NewScanner(file)
-	lineCount := 0
-	for scanner.Scan() && lineCount < 40 {
-		line := scanner.Text()
-		lineCount++
-
-		// Parse based on file type
-		if ext == ".org" {
-			if matches := orgTitleRe.FindStringSubmatch(line); len(matches) > 1 && title == "" {
-				title = strings.TrimSpace(matches[1])
-			}
-			if matches := orgDateRe.FindStringSubmatch(line); len(matches) > 1 && dateStr == "" {
-				dateStr = matches[1]
-			}
-		} else {
-			// Markdown title
-			if matches := mdTitleRe.FindStringSubmatch(line); len(matches) > 1 && title == "" {
-				title = strings.TrimSpace(matches[1])
-			}
-			// Extract **Key:** value metadata
-			if matches := mdMetadataRe.FindStringSubmatch(line); len(matches) > 2 {
-				key := strings.ToLower(strings.TrimSpace(matches[1]))
-				val := cleanMetadataValue(matches[2])
-				switch key {
-				case "date":
-					if dateStr == "" {
-						// Extract YYYY-MM-DD from various date formats
-						if d := extractDate(val); d != "" {
-							dateStr = d
-						}
-					}
-				case "project":
-					metadata["project"] = val
-				case "repository", "repositories", "repo":
-					metadata["repository"] = val
-				case "directory", "working directory":
-					metadata["directory"] = val
-				case "tool":
-					metadata["tool"] = val
-				case "tags":
-					metadata["tags"] = val
-				case "host":
-					metadata["host"] = val
-				}
-			}
-		}
-	}
-
-	// Fallback: extract date from filename
-	if dateStr == "" {
-		if matches := filenameDateRe.FindStringSubmatch(filename); len(matches) > 1 {
-			dateStr = matches[1]
-		} else if matches := filenameDateCompactRe.FindStringSubmatch(filename); len(matches) > 1 {
-			d := matches[1]
-			dateStr = d[:4] + "-" + d[4:6] + "-" + d[6:8]
-		}
-	}
-
-	// Fallback title: use filename without extension and date prefix
-	if title == "" {
-		title = cleanFilename(filename)
-	}
-
-	// Parse date: content > filename > file modification time
-	ts := modTime
-	if dateStr != "" {
-		if parsed, err := time.Parse("2006-01-02", dateStr); err == nil {
-			ts = parsed
-		}
-	}
-
-	return &activity.ActivityItem{
-		ID:        path,
-		Title:     title,
-		Type:      itemType,
-		Category:  activity.CategoryAI,
-		Timestamp: ts,
-		Metadata:  metadata,
-	}, nil
-}
-
-// cleanMetadataValue strips markdown formatting from a metadata value.
-// Removes backticks, trailing parenthetical descriptions, etc.
-func cleanMetadataValue(val string) string {
-	val = strings.TrimSpace(val)
-	// Strip backticks
-	val = strings.ReplaceAll(val, "`", "")
-	return val
-}
-
-// extractDate pulls a YYYY-MM-DD date from various formats:
-// "2026-01-21", "January 21, 2026", "February 18, 2026"
-func extractDate(val string) string {
-	// Direct YYYY-MM-DD
-	if m := filenameDateRe.FindString(val); m != "" {
-		return m
-	}
-	// Try standard Go date parsing for verbose formats
-	for _, layout := range []string{"January 2, 2006", "January 02, 2006", "Jan 2, 2006"} {
-		if t, err := time.Parse(layout, strings.TrimSpace(val)); err == nil {
-			return t.Format("2006-01-02")
-		}
-	}
-	return ""
-}
-
-func cleanFilename(filename string) string {
-	// Remove extension
-	name := strings.TrimSuffix(filename, filepath.Ext(filename))
-
-	// Remove date prefixes
-	name = filenameDateRe.ReplaceAllString(name, "")
-	name = filenameDateCompactRe.ReplaceAllString(name, "")
-
-	// Remove common suffixes
-	name = strings.TrimPrefix(name, "-")
-	name = strings.TrimPrefix(name, "_")
-
-	// Convert underscores and hyphens to spaces, title case
-	name = strings.ReplaceAll(name, "-", " ")
-	name = strings.ReplaceAll(name, "_", " ")
-
-	// Remove timestamp patterns like 145851_SESSION_
-	name = regexp.MustCompile(`^\d{6}_\w+_`).ReplaceAllString(name, "")
-
-	return strings.TrimSpace(name)
-}

@@ -1,54 +0,0 @@
-package sources
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/vdemeester/home/tools/review-tool/internal/config"
-)
-
-func TestAISource_RealHistory(t *testing.T) {
-	home, _ := os.UserHomeDir()
-	aiDir := filepath.Join(home, ".local", "share", "ai")
-
-	if _, err := os.Stat(aiDir); err != nil {
-		t.Skipf("AI history not found at %s", aiDir)
-	}
-
-	cfg := &config.AIConfig{
-		Enabled:          true,
-		Dir:              aiDir,
-		IncludeSessions:  true,
-		IncludeLearnings: true,
-		IncludeResearch:  true,
-		IncludePlans:     true,
-	}
-
-	source := NewAISource(cfg)
-
-	// Last 7 days
-	now := time.Now()
-	start := time.Date(now.Year(), now.Month(), now.Day()-7, 0, 0, 0, 0, now.Location())
-
-	t.Logf("Range: %s to %s", start.Format("2006-01-02"), now.Format("2006-01-02"))
-
-	act, err := source.Fetch(context.Background(), start, now)
-	if err != nil {
-		t.Fatalf("Fetch error: %v", err)
-	}
-
-	t.Logf("Found %d items", len(act.Items))
-	for i, item := range act.Items {
-		if i < 10 {
-			t.Logf("  [%s] %s (%s)", item.Type, item.Title, item.Timestamp.Format("2006-01-02"))
-		}
-	}
-
-	// Should find at least some items in the last 7 days
-	if len(act.Items) == 0 {
-		t.Error("Expected to find some AI history items")
-	}
-}