feat: add backfill command — import tasks from Claude Code session history

Parses ~/.claude/projects/<project>/*.jsonl files and extracts
task-journal events retroactively using heuristics (no LLM needed):
- Session → task (open/close)
- Bash test commands → evidence events
- Git commits → evidence events
- Decision/rejection/constraint keywords → typed events
- File modifications → finding events

Usage: task-journal backfill [--dry-run] [--limit N] [--project path]

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Shahinyanm

crates/tj-cli/src/main.rs

@@ -86,6 +86,19 @@ enum Commands {
     },
     /// Show local classifier and journal statistics.
     Stats,
+    /// Import task-journal events from existing Claude Code session history.
+    /// Parses JSONL session files and creates tasks retroactively.
+    Backfill {
+        /// Dry run: show what would be imported without writing.
+        #[arg(long)]
+        dry_run: bool,
+        /// Limit to N most recent sessions (default: all).
+        #[arg(long)]
+        limit: Option<usize>,
+        /// Project path override (default: current directory).
+        #[arg(long)]
+        project: Option<String>,
+    },
     /// Hook entry point: ingest a chat chunk through the classifier.
     IngestHook {
         /// Hook kind: UserPromptSubmit | PostToolUse | Stop | SessionStart.
@@ -560,6 +573,159 @@ fn main() -> Result<()> {
                 }
             }
         }
+        Commands::Backfill {
+            dry_run,
+            limit,
+            project,
+        } => {
+            use tj_core::session::{discovery, extractor, parser};
+
+            let project_path = match project {
+                Some(p) => std::path::PathBuf::from(p),
+                None => std::env::current_dir()?,
+            };
+
+            let project_hash = tj_core::project_hash::from_path(&project_path)?;
+            let events_dir = tj_core::paths::events_dir()?;
+            let events_path = events_dir.join(format!("{project_hash}.jsonl"));
+
+            // Find the Claude Code project directory for this path.
+            let proj_dir = discovery::find_project_dir(&project_path)?;
+            let proj_dir = match proj_dir {
+                Some(d) => d,
+                None => {
+                    eprintln!(
+                        "No Claude Code sessions found for: {}",
+                        project_path.display()
+                    );
+                    eprintln!(
+                        "Looked in: {}",
+                        discovery::projects_dir()
+                            .map(|p| p.display().to_string())
+                            .unwrap_or_else(|_| "?".into())
+                    );
+                    return Ok(());
+                }
+            };
+
+            // List available sessions.
+            let mut sessions = discovery::list_sessions(&proj_dir)?;
+            if let Some(max) = limit {
+                sessions.truncate(max);
+            }
+
+            if sessions.is_empty() {
+                eprintln!("No session JSONL files found in: {}", proj_dir.display());
+                return Ok(());
+            }
+
+            eprintln!(
+                "Found {} session(s) for {}",
+                sessions.len(),
+                project_path.display()
+            );
+
+            // Check which sessions are already imported (idempotent).
+            let already_imported = if events_path.exists() {
+                let content = std::fs::read_to_string(&events_path).unwrap_or_default();
+                sessions
+                    .iter()
+                    .filter_map(|p| p.file_stem().and_then(|s| s.to_str()).map(String::from))
+                    .filter(|sid| content.contains(sid))
+                    .collect::<std::collections::HashSet<_>>()
+            } else {
+                std::collections::HashSet::new()
+            };
+
+            let mut total_tasks = 0;
+            let mut total_events = 0;
+
+            for session_path in &sessions {
+                let session_id = session_path
+                    .file_stem()
+                    .and_then(|s| s.to_str())
+                    .unwrap_or("?")
+                    .to_string();
+
+                if already_imported.contains(&session_id) {
+                    eprintln!("  ⊘ {} — already imported, skipping", &session_id[..8.min(session_id.len())]);
+                    continue;
+                }
+
+                // Parse the session JSONL.
+                let parsed = match parser::parse_session(session_path) {
+                    Ok(p) => p,
+                    Err(e) => {
+                        eprintln!(
+                            "  ✗ {} — parse error: {}",
+                            &session_id[..8.min(session_id.len())],
+                            e
+                        );
+                        continue;
+                    }
+                };
+
+                // Extract events.
+                let task = match extractor::extract_from_session(&parsed) {
+                    Some(t) => t,
+                    None => {
+                        eprintln!(
+                            "  ⊘ {} — too small ({} msgs), skipping",
+                            &session_id[..8.min(session_id.len())],
+                            parsed.user_message_count()
+                        );
+                        continue;
+                    }
+                };
+
+                if dry_run {
+                    eprintln!(
+                        "  ▸ {} → task {} \"{}\" ({} events)",
+                        &session_id[..8.min(session_id.len())],
+                        task.task_id,
+                        task.title.chars().take(60).collect::<String>(),
+                        task.events.len()
+                    );
+                    for ev in &task.events {
+                        let etype = serde_json::to_value(ev.event_type)
+                            .ok()
+                            .and_then(|v| v.as_str().map(String::from))
+                            .unwrap_or_else(|| "?".into());
+                        eprintln!(
+                            "      {:12} {}",
+                            etype,
+                            ev.text.chars().take(80).collect::<String>()
+                        );
+                    }
+                } else {
+                    // Write events to JSONL.
+                    std::fs::create_dir_all(&events_dir)?;
+                    let mut writer = tj_core::storage::JsonlWriter::open(&events_path)?;
+                    for event in &task.events {
+                        writer.append(event)?;
+                    }
+                    writer.flush_durable()?;
+
+                    eprintln!(
+                        "  ✓ {} → {} \"{}\" ({} events)",
+                        &session_id[..8.min(session_id.len())],
+                        task.task_id,
+                        task.title.chars().take(60).collect::<String>(),
+                        task.events.len()
+                    );
+                }
+
+                total_tasks += 1;
+                total_events += task.events.len();
+            }
+
+            if dry_run {
+                eprintln!("\nDry run: would create {total_tasks} task(s) with {total_events} event(s).");
+                eprintln!("Run without --dry-run to import.");
+            } else {
+                eprintln!("\nImported {total_tasks} task(s) with {total_events} event(s).");
+            }
+        }
     }
     Ok(())
 }

crates/tj-core/src/lib.rs

@@ -8,4 +8,5 @@ pub mod event;
 pub mod pack;
 pub mod paths;
 pub mod project_hash;
+pub mod session;
 pub mod storage;

crates/tj-core/src/session/discovery.rs

@@ -0,0 +1,157 @@
+//! Discover Claude Code session JSONL files for a project.
+//!
+//! Sessions live at `~/.claude/projects/<encoded-path>/<uuid>.jsonl`.
+//! The encoded path replaces non-alphanumeric chars (except `-`) with `-`.
+
+use std::path::{Path, PathBuf};
+
+/// Resolve the Claude Code config directory.
+/// Uses `CLAUDE_CONFIG_DIR` env if set, otherwise `~/.claude`.
+pub fn claude_config_dir() -> anyhow::Result<PathBuf> {
+    if let Ok(custom) = std::env::var("CLAUDE_CONFIG_DIR") {
+        if !custom.is_empty() {
+            return Ok(PathBuf::from(custom));
+        }
+    }
+    let home = dirs_home()?;
+    Ok(home.join(".claude"))
+}
+
+/// Get the projects directory where session files live.
+pub fn projects_dir() -> anyhow::Result<PathBuf> {
+    Ok(claude_config_dir()?.join("projects"))
+}
+
+/// Encode a filesystem path into the Claude Code project directory name format.
+/// Non-alphanumeric chars (except `-`) are replaced with `-`.
+pub fn encode_project_path(path: &str) -> String {
+    path.chars()
+        .map(|c| {
+            if c.is_alphanumeric() || c == '-' {
+                c
+            } else {
+                '-'
+            }
+        })
+        .collect()
+}
+
+/// Find the project directory for a given filesystem path.
+/// Tries exact match first, then prefix match for worktree variants.
+pub fn find_project_dir(project_path: &Path) -> anyhow::Result<Option<PathBuf>> {
+    let projects = projects_dir()?;
+    if !projects.exists() {
+        return Ok(None);
+    }
+
+    let encoded = encode_project_path(&project_path.to_string_lossy());
+
+    // Try exact match first.
+    let exact = projects.join(&encoded);
+    if exact.is_dir() {
+        return Ok(Some(exact));
+    }
+
+    // Try case-insensitive match (WSL paths can differ in case).
+    let encoded_lower = encoded.to_lowercase();
+    if let Ok(entries) = std::fs::read_dir(&projects) {
+        for entry in entries.flatten() {
+            let name = entry.file_name().to_string_lossy().to_string();
+            if name.to_lowercase() == encoded_lower && entry.path().is_dir() {
+                return Ok(Some(entry.path()));
+            }
+        }
+    }
+
+    Ok(None)
+}
+
+/// List all session JSONL files in a project directory.
+/// Excludes agent files (starting with `agent-`).
+/// Returns files sorted by modification time (newest first).
+pub fn list_sessions(project_dir: &Path) -> anyhow::Result<Vec<PathBuf>> {
+    let mut sessions: Vec<(PathBuf, std::time::SystemTime)> = Vec::new();
+
+    for entry in std::fs::read_dir(project_dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        let name = entry.file_name().to_string_lossy().to_string();
+
+        if !name.ends_with(".jsonl") {
+            continue;
+        }
+        // Skip agent sessions.
+        if name.starts_with("agent-") {
+            continue;
+        }
+
+        let mtime = entry
+            .metadata()
+            .and_then(|m| m.modified())
+            .unwrap_or(std::time::UNIX_EPOCH);
+
+        sessions.push((path, mtime));
+    }
+
+    // Sort newest first.
+    sessions.sort_by(|a, b| b.1.cmp(&a.1));
+    Ok(sessions.into_iter().map(|(p, _)| p).collect())
+}
+
+/// List all project directories in Claude Code config.
+pub fn list_all_projects() -> anyhow::Result<Vec<(String, PathBuf)>> {
+    let projects = projects_dir()?;
+    if !projects.exists() {
+        return Ok(vec![]);
+    }
+
+    let mut result = Vec::new();
+    for entry in std::fs::read_dir(&projects)? {
+        let entry = entry?;
+        if entry.path().is_dir() {
+            let name = entry.file_name().to_string_lossy().to_string();
+            // Decode the project name back to a readable path.
+            let decoded = decode_project_path(&name);
+            result.push((decoded, entry.path()));
+        }
+    }
+    result.sort_by(|a, b| a.0.cmp(&b.0));
+    Ok(result)
+}
+
+/// Decode an encoded project directory name back to a readable path.
+/// This is approximate — we can't distinguish `-` from original `/`.
+fn decode_project_path(encoded: &str) -> String {
+    // Common pattern: leading `--` means the path started with a path separator.
+    // Replace double dashes carefully.
+    encoded.to_string()
+}
+
+fn dirs_home() -> anyhow::Result<PathBuf> {
+    directories::BaseDirs::new()
+        .map(|d| d.home_dir().to_path_buf())
+        .ok_or_else(|| anyhow::anyhow!("could not resolve home directory"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn encode_path_replaces_separators() {
+        let encoded = encode_project_path("/home/user/project");
+        assert_eq!(encoded, "-home-user-project");
+    }
+
+    #[test]
+    fn encode_preserves_dashes() {
+        let encoded = encode_project_path("/home/my-project");
+        assert_eq!(encoded, "-home-my-project");
+    }
+
+    #[test]
+    fn encode_wsl_path() {
+        let encoded = encode_project_path("\\\\wsl.localhost\\ubuntu\\home\\user\\project");
+        assert_eq!(encoded, "--wsl-localhost-ubuntu-home-user-project");
+    }
+}