feat(editor): show git blame for current line in status bar

.claude/skills/terax-pr-workflow/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: terax-pr-workflow
+description: Use this skill whenever making ANY change to this repository — features, fixes, shortcuts, refactors, anything. It enforces the mandatory branch → commit → dual-PR (fork + upstream) → merge-fork → back-to-main workflow. Trigger on phrases like "create a PR", "add a feature", "fix this", "push this", "open a pull request", or any task that involves committing and shipping code changes.
+user-invocable: true
+---
+
+# Terax PR Workflow
+
+Every change to this repo MUST follow this exact workflow. No exceptions.
+
+## Remotes
+
+- `origin` → `https://github.com/roberto-fernandino/terax-ai-fork.git` (the fork — you have write access)
+- `upstream` → `https://github.com/crynta/terax-ai.git` (the original — NO push access, use cross-fork PRs)
+
+## Step-by-step
+
+### 1. Create a branch
+
+```bash
+git checkout main
+git pull origin main
+git checkout -b feat/<descriptive-name>
+# or fix/<name>, chore/<name>, etc.
+```
+
+Branch name must be kebab-case and describe the change.
+
+### 2. Make the changes
+
+Implement the feature/fix. Type-check before committing:
+
+```bash
+npx tsc --noEmit
+```
+
+### 3. Commit
+
+Stage only the relevant files (never `git add -A` blindly):
+
+```bash
+git add <specific files>
+git commit -m "$(cat <<'EOF'
+feat/fix/chore(scope): short imperative description
+
+Longer explanation if needed.
+
+Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
+EOF
+)"
+```
+
+### 4. Push to fork
+
+```bash
+git push origin <branch-name>
+```
+
+### 5. Check for existing open PRs — BEFORE creating new ones
+
+**This step is mandatory.** Before opening any PR, check whether one already exists for the same feature area:
+
+```bash
+gh pr list --repo roberto-fernandino/terax-ai-fork --state open
+gh pr list --repo crynta/terax-ai --author roberto-fernandino --state open
+```
+
+- If an open PR exists for the same feature/area → push commits to that branch and update the existing PR. Do NOT create a new one.
+- Only create a new PR if no related open PR exists.
+
+Related means: same feature, same subsystem, or a fix that belongs to an in-progress feature branch. When in doubt, add to the existing PR.
+
+### 6. Create PR on the fork (roberto-fernandino/terax-ai-fork)
+
+Only if no existing open PR covers this change:
+
+```bash
+gh pr create \
+  --repo roberto-fernandino/terax-ai-fork \
+  --base main \
+  --head <branch-name> \
+  --title "<same as commit title>" \
+  --body "$(cat <<'EOF'
+## Summary
+- bullet points
+
+## Test plan
+- [ ] item
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+EOF
+)"
+```
+
+### 7. Create cross-fork PR on the upstream (crynta/terax-ai)
+
+Only if no existing open upstream PR covers this change. Push access is denied to upstream, so use the fork branch as head:
+
+```bash
+gh pr create \
+  --repo crynta/terax-ai \
+  --base main \
+  --head roberto-fernandino:<branch-name> \
+  --title "<same as commit title>" \
+  --body "..."
+```
+
+### 8. Merge the fork PR
+
+```bash
+gh pr merge <pr-number> --repo roberto-fernandino/terax-ai-fork --merge --auto
+```
+
+### 9. Return to main and pull
+
+```bash
+git checkout main
+git pull origin main
+```
+
+## Rules
+
+- ALWAYS create a branch — never commit directly to main.
+- ALWAYS check for existing open PRs before creating new ones (step 5). Push to the existing branch/PR when the change belongs to the same feature or subsystem.
+- ALWAYS open TWO PRs when creating new ones: one on the fork, one on the upstream (cross-fork).
+- ALWAYS merge the fork PR and return to main at the end.
+- NEVER push directly to upstream (no access); always use `--head roberto-fernandino:<branch>` for the upstream PR.
+- NEVER open a new PR for a fix that belongs to an existing open feature PR — add the commit to that branch instead.
+- Type-check (`npx tsc --noEmit`) before committing.
+- Use conventional commit prefixes: `feat`, `fix`, `chore`, `refactor`, `docs`.

src-tauri/src/lib.rs

@@ -235,6 +235,7 @@ pub fn run() {
             git::commands::git_remote_url,
             git::commands::git_list_branches,
             git::commands::git_checkout_branch,
+            git::commands::git_blame,
             shell::shell_run_command,
             shell::shell_session_open,
             shell::shell_session_run,

src-tauri/src/modules/git/commands.rs

@@ -2,7 +2,7 @@ use tauri::{AppHandle, Manager};
 
 use crate::modules::git::operations;
 use crate::modules::git::types::{
-    DiscardEntry, GitBranchListResult, GitCommitFileChange, GitCommitResult,
+    DiscardEntry, GitBlameLineInfo, GitBranchListResult, GitCommitFileChange, GitCommitResult,
     GitDiffContentResult, GitDiffResult, GitLogEntry, GitPanelSnapshot, GitPushResult,
     GitRepoInfo, GitStatusSnapshot,
 };
@@ -309,3 +309,18 @@ pub async fn git_checkout_branch(
     })
     .await
 }
+
+#[tauri::command]
+pub async fn git_blame(
+    cwd: String,
+    path: String,
+    line: u32,
+    workspace: Option<WorkspaceEnv>,
+    app: AppHandle,
+) -> Result<Option<GitBlameLineInfo>, String> {
+    let workspace = WorkspaceEnv::from_option(workspace);
+    blocking(app, move |r| {
+        operations::blame_line(r, &cwd, &path, line, &workspace).map_err(Into::into)
+    })
+    .await
+}

src-tauri/src/modules/git/operations.rs

@@ -8,8 +8,8 @@ use crate::modules::git::process::{
     read_text_file, run_git,
 };
 use crate::modules::git::types::{
-    DiscardEntry, GitBranchEntry, GitBranchListResult, GitCommitFileChange, GitCommitResult,
-    GitDiffContentResult, GitDiffResult, GitLogEntry, GitOutput, GitPanelSnapshot,
+    DiscardEntry, GitBlameLineInfo, GitBranchEntry, GitBranchListResult, GitCommitFileChange,
+    GitCommitResult, GitDiffContentResult, GitDiffResult, GitLogEntry, GitOutput, GitPanelSnapshot,
     GitPushResult, GitRepoInfo, GitStatusSnapshot, TextSource, DEFAULT_TIMEOUT_SECS,
     NETWORK_TIMEOUT_SECS,
 };
@@ -1147,6 +1147,59 @@ pub fn checkout_branch(
     ensure_success(&output, "git checkout failed")
 }
 
+pub fn blame_line(
+    registry: &WorkspaceRegistry,
+    cwd: &str,
+    path: &str,
+    line: u32,
+    workspace: &WorkspaceEnv,
+) -> Result<Option<GitBlameLineInfo>> {
+    if line == 0 {
+        return Ok(None);
+    }
+    let dir = canonical_dir(registry, cwd, workspace)?;
+    if !registry.is_authorized(&dir.local_path) {
+        return Err(GitError::PathOutsideWorkspace(dir.local_path));
+    }
+    ensure_git_available(&dir.workspace)?;
+
+    let line_spec = format!("{},{}", line, line);
+    let output = run_git(
+        &dir.workspace,
+        Some(&dir.git_path),
+        ["blame", "-L", &line_spec, "--porcelain", "--", path],
+        DEFAULT_TIMEOUT_SECS,
+    )?;
+
+    if output.exit_code != Some(0) {
+        return Ok(None);
+    }
+
+    let text = String::from_utf8_lossy(&output.stdout);
+    let mut author: Option<String> = None;
+    let mut timestamp: Option<i64> = None;
+
+    for line_text in text.lines() {
+        if let Some(name) = line_text.strip_prefix("author ") {
+            author = Some(name.to_string());
+        } else if let Some(ts) = line_text.strip_prefix("author-time ") {
+            if let Ok(t) = ts.trim().parse::<i64>() {
+                timestamp = Some(t);
+            }
+        }
+        if author.is_some() && timestamp.is_some() {
+            break;
+        }
+    }
+
+    Ok(match (author, timestamp) {
+        (Some(a), Some(t)) if a != "Not Committed Yet" => {
+            Some(GitBlameLineInfo { author: a, timestamp: t })
+        }
+        _ => None,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src-tauri/src/modules/git/types.rs

@@ -131,6 +131,13 @@ pub struct GitBranchListResult {
     pub branches: Vec<GitBranchEntry>,
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GitBlameLineInfo {
+    pub author: String,
+    pub timestamp: i64,
+}
+
 pub(crate) struct GitOutput {
     pub(crate) stdout: Vec<u8>,
     pub(crate) stderr: Vec<u8>,