Merge branch 'live' into task/t-rWa5yilwM.3

5 files changed, 250 insertions, 29 deletions

diff --git a/Omni/Agent/Git.hs b/Omni/Agent/Git.hs
new file mode 100644
index 0000000..cbb63bd
--- /dev/null
+++ b/Omni/Agent/Git.hs
@@ -0,0 +1,139 @@
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+
+-- | Git operations for the agent.
+--
+-- : out omni-agent-git
+-- : dep temporary
+module Omni.Agent.Git
+  ( checkout,
+    main,
+    test,
+  )
+where
+
+import Alpha
+import qualified Data.Text as Text
+import qualified Omni.Log as Log
+import Omni.Test ((@=?))
+import qualified Omni.Test as Test
+import qualified System.Directory as Directory
+import qualified System.Exit as Exit
+import qualified System.IO.Temp as Temp
+import qualified System.Process as Process
+
+main :: IO ()
+main = Test.run test
+
+test :: Test.Tree
+test =
+  Test.group
+    "Omni.Agent.Git"
+    [ Test.unit "checkout works" <| do
+        Temp.withSystemTempDirectory "omni-agent-git-test" <| \tmpDir -> do
+          let repo = tmpDir <> "/repo"
+          Directory.createDirectory repo
+          -- init repo
+          git repo ["init"]
+          git repo ["branch", "-m", "master"]
+          git repo ["config", "user.email", "you@example.com"]
+          git repo ["config", "user.name", "Your Name"]
+          
+          -- commit A
+          writeFile (repo <> "/a.txt") "A"
+          git repo ["add", "a.txt"]
+          git repo ["commit", "-m", "A"]
+          shaA <- getSha repo "HEAD"
+
+          -- create branch dev
+          git repo ["checkout", "-b", "dev"]
+          
+          -- commit B
+          writeFile (repo <> "/b.txt") "B"
+          git repo ["add", "b.txt"]
+          git repo ["commit", "-m", "B"]
+          shaB <- getSha repo "HEAD"
+          
+          -- switch back to master
+          git repo ["checkout", "master"]
+          
+          -- Test 1: checkout dev
+          checkout repo "dev"
+          current <- getSha repo "HEAD"
+          shaB @=? current
+          
+          -- Test 2: checkout master
+          checkout repo "master"
+          current' <- getSha repo "HEAD"
+          shaA @=? current'
+          
+          -- Test 3: dirty state
+          writeFile (repo <> "/a.txt") "DIRTY"
+          checkout repo "dev"
+          current'' <- getSha repo "HEAD"
+          shaB @=? current''
+          -- Verify dirty file is gone/overwritten (b.txt should exist, a.txt should be A from master? No, a.txt is in A and B)
+          -- Wait, in dev, a.txt is "A".
+          content <- readFile (repo <> "/a.txt")
+          "A" @=? content
+          
+          -- Test 4: untracked file
+          writeFile (repo <> "/untracked.txt") "DELETE ME"
+          checkout repo "master"
+          exists <- Directory.doesFileExist (repo <> "/untracked.txt")
+          False @=? exists
+    ]
+
+getSha :: FilePath -> String -> IO String
+getSha dir ref = do
+  let cmd = (Process.proc "git" ["rev-parse", ref]) {Process.cwd = Just dir}
+  (code, out, _) <- Process.readCreateProcessWithExitCode cmd ""
+  case code of
+    Exit.ExitSuccess -> pure <| strip out
+    _ -> panic "getSha failed"
+
+-- | Checkout a specific ref (SHA, branch, tag) in the given repository path.
+-- This function ensures the repository is in the correct state by:
+-- 1. Fetching all updates
+-- 2. Checking out the ref (forcing overwrites of local changes)
+-- 3. Resetting hard to the ref (to ensure clean state)
+-- 4. Cleaning untracked files
+-- 5. Updating submodules
+checkout :: FilePath -> Text -> IO ()
+checkout repoPath ref = do
+  let r = Text.unpack ref
+  
+  Log.info ["git", "checkout", ref, "in", Text.pack repoPath]
+  
+  -- Fetch all refs to ensure we have the target
+  git repoPath ["fetch", "--all", "--tags"]
+
+  -- Checkout the ref, discarding local changes
+  git repoPath ["checkout", "--force", r]
+
+  -- Reset hard to ensure we are exactly at the target state
+  git repoPath ["reset", "--hard", r]
+
+  -- Remove untracked files and directories
+  git repoPath ["clean", "-fdx"]
+
+  -- Update submodules
+  git repoPath ["submodule", "update", "--init", "--recursive"]
+  
+  Log.good ["git", "checkout", "complete"]
+  Log.br
+
+-- | Run a git command in the given directory.
+git :: FilePath -> [String] -> IO ()
+git dir args = do
+  let cmd = (Process.proc "git" args) {Process.cwd = Just dir}
+  (exitCode, out, err) <- Process.readCreateProcessWithExitCode cmd ""
+  case exitCode of
+    Exit.ExitSuccess -> pure ()
+    Exit.ExitFailure code -> do
+      Log.fail ["git command failed", Text.pack (show args), "code: " <> show code]
+      Log.info [Text.pack out]
+      Log.info [Text.pack err]
+      Log.br
+      panic <| "git command failed: git " <> show args
diff --git a/Omni/Bild.hs b/Omni/Bild.hs
index 53d96a5..ba54c93 100644
--- a/Omni/Bild.hs
+++ b/Omni/Bild.hs
@@ -653,7 +653,8 @@ analyzeAll isPlanMode nss = do
           contentLines
             |> Meta.detectAll "--"
             |> \Meta.Parsed {..} ->
-              detectHaskellImports mempty contentLines +> \(langdeps, srcs) -> do
+              detectHaskellImports mempty contentLines +> \(autoDeps, srcs) -> do
+                let langdeps = autoDeps <> pdep
                 graph <- buildHsModuleGraph namespace quapath srcs
                 pure
                   <| Just
diff --git a/Omni/Bild/Deps/Haskell.nix b/Omni/Bild/Deps/Haskell.nix
index 5d6abbb..6930860 100644
--- a/Omni/Bild/Deps/Haskell.nix
+++ b/Omni/Bild/Deps/Haskell.nix
@@ -54,6 +54,7 @@
   "tasty"
   "tasty-hunit"
   "tasty-quickcheck"
+  "temporary"
   "text"
   "time"
   "transformers"
diff --git a/Omni/Task.hs b/Omni/Task.hs
index 24e528b..f3baf15 100644
--- a/Omni/Task.hs
+++ b/Omni/Task.hs
@@ -45,7 +45,8 @@ Usage:
   task update <id> <status> [--json]
   task deps <id> [--json]
   task tree [<id>] [--json]
-  task stats [--json]
+  task progress <id> [--json]
+  task stats [--epic=<id>] [--json]
   task export [--flush]
   task import -i <file>
   task sync
@@ -61,6 +62,7 @@ Commands:
   update                        Update task status
   deps                          Show dependency tree
   tree                          Show task tree (epics with children, or all epics if no ID given)
+  progress                      Show progress for an epic
   stats                         Show task statistics
   export                        Export and consolidate tasks to JSONL
   import                        Import tasks from JSONL file
@@ -73,6 +75,7 @@ Options:
   --parent=<id>                 Parent epic ID
   --priority=<p>                Priority: 0-4 (0=critical, 4=backlog, default: 2)
   --status=<status>             Filter by status: open, in-progress, review, done
+  --epic=<id>                   Filter stats by epic (recursive)
   --deps=<ids>                  Comma-separated list of dependency IDs
   --dep-type=<type>             Dependency type: blocks, discovered-from, parent-child, related (default: blocks)
   --discovered-from=<id>        Shortcut for --deps=<id> --dep-type=discovered-from
@@ -231,12 +234,22 @@ move args
           tree <- getTaskTree maybeId
           outputJson tree
         else showTaskTree maybeId
+  | args `Cli.has` Cli.command "progress" = do
+      tid <- getArgText args "id"
+      if isJsonMode args
+        then do
+          progress <- getTaskProgress tid
+          outputJson progress
+        else showTaskProgress tid
   | args `Cli.has` Cli.command "stats" = do
+      maybeEpic <- case Cli.getArg args (Cli.longOption "epic") of
+        Nothing -> pure Nothing
+        Just e -> pure <| Just (T.pack e)
       if isJsonMode args
         then do
-          stats <- getTaskStats
+          stats <- getTaskStats maybeEpic
           outputJson stats
-        else showTaskStats
+        else showTaskStats maybeEpic
   | args `Cli.has` Cli.command "export" = do
       exportTasks
       putText "Exported and consolidated tasks to .tasks/tasks.jsonl"
@@ -336,20 +349,21 @@ unitTests =
         child1 <- createTask "Child 1" WorkTask (Just (taskId parent)) Nothing P2 []
         -- Manually create a task with .3 suffix to simulate a gap (or deleted task)
         let child3Id = taskId parent <> ".3"
-            child3 = Task
-              { taskId = child3Id,
-                taskTitle = "Child 3",
-                taskType = WorkTask,
-                taskParent = Just (taskId parent),
-                taskNamespace = Nothing,
-                taskStatus = Open,
-                taskPriority = P2,
-                taskDependencies = [],
-                taskCreatedAt = taskCreatedAt child1,
-                taskUpdatedAt = taskUpdatedAt child1
-              }
+            child3 =
+              Task
+                { taskId = child3Id,
+                  taskTitle = "Child 3",
+                  taskType = WorkTask,
+                  taskParent = Just (taskId parent),
+                  taskNamespace = Nothing,
+                  taskStatus = Open,
+                  taskPriority = P2,
+                  taskDependencies = [],
+                  taskCreatedAt = taskCreatedAt child1,
+                  taskUpdatedAt = taskUpdatedAt child1
+                }
         saveTask child3
-        
+
         -- Create a new child, it should get .4, not .2
         child4 <- createTask "Child 4" WorkTask (Just (taskId parent)) Nothing P2 []
         taskId child4 Test.@?= taskId parent <> ".4"
@@ -516,6 +530,13 @@ cliTests =
           Right args -> do
             args `Cli.has` Cli.command "stats" Test.@?= True
             args `Cli.has` Cli.longOption "json" Test.@?= True,
+      Test.unit "stats with --epic flag" <| do
+        let result = Docopt.parseArgs help ["stats", "--epic=t-abc123"]
+        case result of
+          Left err -> Test.assertFailure <| "Failed to parse 'stats --epic': " <> show err
+          Right args -> do
+            args `Cli.has` Cli.command "stats" Test.@?= True
+            Cli.getArg args (Cli.longOption "epic") Test.@?= Just "t-abc123",
       Test.unit "create with flags in different order" <| do
         let result = Docopt.parseArgs help ["create", "Test", "--json", "--priority=1", "--namespace=Omni/Task"]
         case result of
diff --git a/Omni/Task/Core.hs b/Omni/Task/Core.hs
index e4f1086..622e8de 100644
--- a/Omni/Task/Core.hs
+++ b/Omni/Task/Core.hs
@@ -57,6 +57,14 @@ data DependencyType
   | Related -- Soft relationship, doesn't block
   deriving (Show, Eq, Generic)
 
+data TaskProgress = TaskProgress
+  { progressTaskId :: Text,
+    progressTotal :: Int,
+    progressCompleted :: Int,
+    progressPercentage :: Int
+  }
+  deriving (Show, Eq, Generic)
+
 instance ToJSON TaskType
 
 instance FromJSON TaskType
@@ -81,6 +89,10 @@ instance ToJSON Task
 
 instance FromJSON Task
 
+instance ToJSON TaskProgress
+
+instance FromJSON TaskProgress
+
 -- Get the tasks database file path (use test file if TASK_TEST_MODE is set)
 getTasksFilePath :: IO FilePath
 getTasksFilePath = do
@@ -309,6 +321,32 @@ getDependencyTree tid = do
           deps = filter (\t -> taskId t `elem` depIds) allTasks
        in task : concatMap (collectDeps allTasks) deps
 
+-- Get task progress
+getTaskProgress :: Text -> IO TaskProgress
+getTaskProgress tid = do
+  tasks <- loadTasks
+  -- Verify task exists (optional, but good for error handling)
+  case filter (\t -> taskId t == tid) tasks of
+    [] -> panic "Task not found"
+    _ -> do
+      let children = filter (\child -> taskParent child == Just tid) tasks
+          total = length children
+          completed = length <| filter (\child -> taskStatus child == Done) children
+          percentage = if total == 0 then 0 else (completed * 100) `div` total
+      pure
+        TaskProgress
+          { progressTaskId = tid,
+            progressTotal = total,
+            progressCompleted = completed,
+            progressPercentage = percentage
+          }
+
+-- Show task progress
+showTaskProgress :: Text -> IO ()
+showTaskProgress tid = do
+  progress <- getTaskProgress tid
+  putText <| "Progress for " <> tid <> ": " <> T.pack (show (progressCompleted progress)) <> "/" <> T.pack (show (progressTotal progress)) <> " (" <> T.pack (show (progressPercentage progress)) <> "%)"
+
 -- Show dependency tree for a task
 showDependencyTree :: Text -> IO ()
 showDependencyTree tid = do
@@ -518,18 +556,31 @@ instance ToJSON TaskStats
 instance FromJSON TaskStats
 
 -- Get task statistics
-getTaskStats :: IO TaskStats
-getTaskStats = do
-  tasks <- loadTasks
-  ready <- getReadyTasks
-  let total = length tasks
+getTaskStats :: Maybe Text -> IO TaskStats
+getTaskStats maybeEpicId = do
+  allTasks <- loadTasks
+
+  targetTasks <- case maybeEpicId of
+    Nothing -> pure allTasks
+    Just epicId ->
+      case filter (\t -> taskId t == epicId) allTasks of
+        [] -> panic "Epic not found"
+        _ -> pure <| getAllDescendants allTasks epicId
+
+  globalReady <- getReadyTasks
+  let readyIds = map taskId globalReady
+      -- Filter ready tasks to only include those in our target set
+      readyCount = length <| filter (\t -> taskId t `elem` readyIds) targetTasks
+
+      tasks = targetTasks
+      total = length tasks
       open = length <| filter (\t -> taskStatus t == Open) tasks
       inProg = length <| filter (\t -> taskStatus t == InProgress) tasks
       review = length <| filter (\t -> taskStatus t == Review) tasks
       done = length <| filter (\t -> taskStatus t == Done) tasks
       epics = length <| filter (\t -> taskType t == Epic) tasks
-      readyCount = length ready
-      blockedCount = total - readyCount - done
+      readyCount' = readyCount
+      blockedCount = total - readyCount' - done
       -- Count tasks by priority
       byPriority =
         [ (P0, length <| filter (\t -> taskPriority t == P0) tasks),
@@ -550,18 +601,26 @@ getTaskStats = do
         reviewTasks = review,
         doneTasks = done,
         totalEpics = epics,
-        readyTasks = readyCount,
+        readyTasks = readyCount',
         blockedTasks = blockedCount,
         tasksByPriority = byPriority,
         tasksByNamespace = byNamespace
       }
 
+-- Helper to get all descendants of a task (recursive)
+getAllDescendants :: [Task] -> Text -> [Task]
+getAllDescendants allTasks parentId =
+  let children = filter (\t -> taskParent t == Just parentId) allTasks
+   in children ++ concatMap (getAllDescendants allTasks <. taskId) children
+
 -- Show task statistics (human-readable)
-showTaskStats :: IO ()
-showTaskStats = do
-  stats <- getTaskStats
+showTaskStats :: Maybe Text -> IO ()
+showTaskStats maybeEpicId = do
+  stats <- getTaskStats maybeEpicId
   putText ""
-  putText "Task Statistics"
+  case maybeEpicId of
+    Nothing -> putText "Task Statistics"
+    Just epicId -> putText <| "Task Statistics for Epic " <> epicId
   putText ""
   putText <| "Total tasks:       " <> T.pack (show (totalTasks stats))
   putText <| "  Open:            " <> T.pack (show (openTasks stats))