Fix: case-insensitive task IDs

Amp-Thread-ID:
https://ampcode.com/threads/T-ffe97b65-9fa4-4cd2-a708-ebbf0b74d57f
Co-authored-by: Amp <amp@ampcode.com>

2 files changed, 71 insertions, 22 deletions

diff --git a/Omni/Task.hs b/Omni/Task.hs
index 36b318b..a6f6bb4 100644
--- a/Omni/Task.hs
+++ b/Omni/Task.hs
@@ -205,9 +205,9 @@ move args
   | args `Cli.has` Cli.command "show" = do
       tid <- getArgText args "id"
       tasks <- loadTasks
-      case filter (\t -> taskId t == tid) tasks of
-        [] -> putText "Task not found"
-        (task : _) ->
+      case findTask tid tasks of
+        Nothing -> putText "Task not found"
+        Just task ->
           if isJsonMode args
             then outputJson task
             else showTaskDetailed task
@@ -397,7 +397,31 @@ unitTests =
       Test.unit "namespace normalization handles .hs suffix" <| do
         let ns = "Omni/Task.hs"
             validNs = Namespace.fromHaskellModule ns
-        Namespace.toPath validNs Test.@?= "Omni/Task.hs"
+        Namespace.toPath validNs Test.@?= "Omni/Task.hs",
+      Test.unit "generated IDs are lowercase" <| do
+        task <- createTask "Lowercase check" WorkTask Nothing Nothing P2 [] Nothing
+        let tid = taskId task
+        tid Test.@?= T.toLower tid
+        -- check it matches regex for base36 (t-[0-9a-z]+)
+        let isLowerBase36 = T.all (\c -> c `elem` ['0' .. '9'] ++ ['a' .. 'z'] || c == 't' || c == '-') tid
+        isLowerBase36 Test.@?= True,
+      Test.unit "dependencies are case insensitive" <| do
+        task1 <- createTask "Blocker" WorkTask Nothing Nothing P2 [] Nothing
+        let tid1 = taskId task1
+            -- Use uppercase ID for dependency
+            upperTid1 = T.toUpper tid1
+            dep = Dependency {depId = upperTid1, depType = Blocks}
+        task2 <- createTask "Blocked" WorkTask Nothing Nothing P2 [dep] Nothing
+
+        -- task1 is Open, so task2 should NOT be ready
+        ready <- getReadyTasks
+        (taskId task2 `notElem` map taskId ready) Test.@?= True
+
+        updateTaskStatus tid1 Done
+
+        -- task2 should now be ready because dependency check normalizes IDs
+        ready2 <- getReadyTasks
+        (taskId task2 `elem` map taskId ready2) Test.@?= True
     ]
 
 -- | Test CLI argument parsing to ensure docopt string matches actual usage
diff --git a/Omni/Task/Core.hs b/Omni/Task/Core.hs
index bab1912..7bb8ef0 100644
--- a/Omni/Task/Core.hs
+++ b/Omni/Task/Core.hs
@@ -96,11 +96,32 @@ instance FromJSON Task
 
 -- | Case-insensitive ID comparison
 matchesId :: Text -> Text -> Bool
-matchesId id1 id2 = T.toLower id1 == T.toLower id2
+matchesId id1 id2 = normalizeId id1 == normalizeId id2
+
+-- | Normalize ID to lowercase
+normalizeId :: Text -> Text
+normalizeId = T.toLower
 
 -- | Find a task by ID (case-insensitive)
 findTask :: Text -> [Task] -> Maybe Task
 findTask tid = List.find (\t -> matchesId (taskId t) tid)
+  where
+    -- Helper to check if IDs match
+    -- matchesId is already defined globally but we can use it directly
+    -- The lambda above is fine.
+    () = ()
+
+-- | Normalize task IDs (self, parent, dependencies) to lowercase
+normalizeTask :: Task -> Task
+normalizeTask t =
+  t
+    { taskId = normalizeId (taskId t),
+      taskParent = fmap normalizeId (taskParent t),
+      taskDependencies = map normalizeDependency (taskDependencies t)
+    }
+
+normalizeDependency :: Dependency -> Dependency
+normalizeDependency d = d {depId = normalizeId (depId d)}
 
 instance ToJSON TaskProgress
 
@@ -188,7 +209,7 @@ generateId = do
       -- Combine MJD and micros to ensure uniqueness across days.
       -- Multiplier 10^11 (100,000 seconds) is safe for any day length.
       totalMicros = (mjd * 100000000000) + micros
-      encoded = toBase62 totalMicros
+      encoded = toBase36 totalMicros
   pure <| "t-" <> T.pack encoded
 
 -- Generate a child ID based on parent ID (e.g. "t-abc.1", "t-abc.1.2")
@@ -197,7 +218,7 @@ generateChildId :: Text -> IO Text
 generateChildId parentId =
   withTaskReadLock <| do
     tasks <- loadTasksInternal
-    pure <| computeNextChildId tasks parentId
+    pure <| computeNextChildId tasks (normalizeId parentId)
 
 computeNextChildId :: [Task] -> Text -> Text
 computeNextChildId tasks parentId =
@@ -220,15 +241,15 @@ getSuffix parent childId =
             else Nothing
     else Nothing
 
--- Convert number to base62 (0-9, a-z, A-Z)
-toBase62 :: Integer -> String
-toBase62 0 = "0"
-toBase62 n = reverse <| go n
+-- Convert number to base36 (0-9, a-z)
+toBase36 :: Integer -> String
+toBase36 0 = "0"
+toBase36 n = reverse <| go n
   where
-    alphabet = ['0' .. '9'] ++ ['a' .. 'z'] ++ ['A' .. 'Z']
+    alphabet = ['0' .. '9'] ++ ['a' .. 'z']
     go 0 = []
     go x =
-      let (q, r) = x `divMod` 62
+      let (q, r) = x `divMod` 36
           idx = fromIntegral r
           char = case drop idx alphabet of
             (c : _) -> c
@@ -319,7 +340,10 @@ saveTaskInternal task = do
 createTask :: Text -> TaskType -> Maybe Text -> Maybe Text -> Priority -> [Dependency] -> Maybe Text -> IO Task
 createTask title taskType parent namespace priority deps description =
   withTaskWriteLock <| do
-    tid <- case parent of
+    let parent' = fmap normalizeId parent
+        deps' = map normalizeDependency deps
+
+    tid <- case parent' of
       Nothing -> generateId
       Just pid -> do
         tasks <- loadTasksInternal
@@ -327,14 +351,14 @@ createTask title taskType parent namespace priority deps description =
     now <- getCurrentTime
     let task =
           Task
-            { taskId = tid,
+            { taskId = normalizeId tid,
               taskTitle = title,
               taskType = taskType,
-              taskParent = parent,
+              taskParent = parent',
               taskNamespace = namespace,
               taskStatus = Open,
               taskPriority = priority,
-              taskDependencies = deps,
+              taskDependencies = deps',
               taskDescription = description,
               taskCreatedAt = now,
               taskUpdatedAt = now
@@ -415,12 +439,13 @@ getDependencyTree tid = do
 
 -- Get task progress
 getTaskProgress :: Text -> IO TaskProgress
-getTaskProgress tid = do
+getTaskProgress tidRaw = do
+  let tid = normalizeId tidRaw
   tasks <- loadTasks
   -- Verify task exists (optional, but good for error handling)
-  case filter (\t -> taskId t == tid) tasks of
-    [] -> panic "Task not found"
-    _ -> do
+  case findTask tid tasks of
+    Nothing -> panic "Task not found"
+    Just _ -> do
       let children = filter (\child -> taskParent child == Just tid) tasks
           total = length children
           completed = length <| filter (\child -> taskStatus child == Done) children
@@ -815,7 +840,7 @@ importTasks filePath =
     -- Load tasks from import file
     content <- TIO.readFile filePath
     let importLines = T.lines content
-        importedTasks = mapMaybe decodeTask importLines
+        importedTasks = map normalizeTask (mapMaybe decodeTask importLines)
 
     -- Load existing tasks
     existingTasks <- loadTasksInternal