taskchampion-rb 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '029205bd9244f841d99e2913b09dd0e631ef11c28e3ddbc4745d54c9731248ad'
-  data.tar.gz: 45c862f0b82dba0187025aaee04c85be748aa9f24a17f28428dbd9ff9827b710
+  metadata.gz: 8b267de15e0004e931e2a46f37f9014afe8fdc52e58e675190dab990cb345e75
+  data.tar.gz: 6a84efc5a165c428c67e6d50f3ce0b001eab4d3fde464ffed123d218aaf04033
 SHA512:
-  metadata.gz: 9379b9c99bb21c7a23beeda1f92756f31f22543b05600e11302650575063e52fe23c99a49b8a51c875f602e4d88f022aaf11681232a2a66fe1201f44116d3055
-  data.tar.gz: 0745ae9e0c8350b27318c7bd741d4dfaf92921c714b396f2bfeb3c277a8d89260aa53fe2a99c63b036e65e36e9e365398ffd0729ca5bc64b209266f80ba49e0f
+  metadata.gz: ff860c7dcb85bc6a04aced731b403072a03c3a222f869fec0a25af1436b14fb67e4df0a9dc5cfad4d829b1fe1f39936e6df07c90605eb859202ac8f80fc8a17f
+  data.tar.gz: d826c3704fec6432e872abe24423d92e04da810c0718ce0cc224dbddd780b2279b336c635bd1e285405bd4534710fbd9928bf4ee7c5f225f4118baade8315436

data/.ruby-version

@@ -0,0 +1 @@
+3.2.0

data/README.md

@@ -2,11 +2,19 @@
 
 Ruby bindings for TaskChampion, the task database that powers Taskwarrior.
 
+## Ruby Version Support (2025-08-12)
+
+This gem supports Ruby 3.2 and later. We follow Ruby's end-of-life (EOL) schedule and drop support for Ruby versions that have reached EOL.
+
+- **Ruby 3.2**: Supported (EOL: March 2026)
+- **Ruby 3.3**: Supported (Current stable)
+- **Ruby 3.0-3.1**: Not supported (reached EOL)
+
 ## Installation
 
 ### Prerequisites
 
-1. Ruby 3.0 or later
+1. Ruby 3.2 or later
 2. Rust toolchain (install from https://rustup.rs/)
 
 ```bash

data/Rakefile

@@ -26,3 +26,17 @@ end
 task test: :compile
 
 task default: %i[compile test]
+
+desc "Bump version, create tag, and release gem"
+task :publish, [:version] do |t, args|
+  version = args[:version] || "patch"
+
+  puts "Bumping version (#{version})..."
+  sh "bump #{version} --tag"
+
+  puts "Pushing to git..."
+  sh "git push && git push --tags"
+
+  puts "Building and releasing gem..."
+  Rake::Task["release"].invoke
+end

data/docs/breakthrough.md

@@ -91,7 +91,7 @@ impl Replica {
         Ok(Replica(ThreadBound::new(replica))) // ✅ Wrapped in ThreadBound
     }
 
-    fn tasks(&self) -> Result<RHash, Error> {
+    fn all_tasks(&self) -> Result<RHash, Error> {
         let mut tc_replica = self.0.get_mut()?; // ✅ Thread check + access
         let tasks = tc_replica.all_tasks().map_err(into_error)?;
         // ... process tasks

data/docs/plan.md

@@ -453,7 +453,7 @@ task1.set_status(:pending)
 replica.commit_operations(operations)
 
 # Query tasks
-all_tasks = replica.tasks
+all_tasks = replica.all_tasks
 puts "Total tasks: #{all_tasks.size}"
 
 # Sync with server (if configured)

data/examples/basic_usage.rb

@@ -18,7 +18,7 @@ db_path = File.join(temp_dir, "tasks")
 begin
   # 1. CREATE TASK DATABASE
   puts "\n1. Creating task database at #{db_path}"
-  replica = Taskchampion::Replica.new_on_disk(db_path, create_if_missing: true)
+  replica = Taskchampion::Replica.new_on_disk(db_path, true, :read_write)
 
   # 2. CREATE AND MODIFY TASKS
   puts "\n2. Creating and modifying tasks"
@@ -39,8 +39,7 @@ begin
   task1.add_tag(Taskchampion::Tag.new("ruby"), operations)
 
   # Add annotation
-  annotation = Taskchampion::Annotation.new(Time.now, "Started learning TaskChampion")
-  task1.add_annotation(annotation, operations)
+  task1.add_annotation("Started learning TaskChampion", operations)
 
   # Create second task
   uuid2 = SecureRandom.uuid
@@ -61,7 +60,6 @@ begin
   task3.set_description("Read TaskChampion documentation", operations)
   task3.set_status(Taskchampion::Status.completed, operations)
   task3.add_tag(Taskchampion::Tag.new("learning"), operations)
-  task3.set_end(Time.now, operations)
 
   # 3. COMMIT CHANGES TO STORAGE
   puts "\n3. Committing changes to storage"
@@ -88,14 +86,13 @@ begin
 
     # Display tags
     if !task.tags.empty?
-      tag_names = task.tags.map(&:name)
+      tag_names = task.tags.map(&:to_s)
       puts "  Tags: #{tag_names.join(', ')}"
     end
 
     # Display dates
     puts "  Created: #{task.entry.strftime('%Y-%m-%d %H:%M:%S')}" if task.entry
     puts "  Due: #{task.due.strftime('%Y-%m-%d %H:%M:%S')}" if task.due
-    puts "  Completed: #{task.end.strftime('%Y-%m-%d %H:%M:%S')}" if task.end
 
     # Display annotations
     if !task.annotations.empty?
@@ -136,29 +133,42 @@ begin
 
   # Find tasks due today or tomorrow
   tomorrow = Time.now + 86400
-  due_soon = all_tasks.select { |t| t.due && t.due <= tomorrow }
+  due_soon = all_tasks.select { |t| t.due && t.due.to_time <= tomorrow }
   puts "Tasks due soon: #{due_soon.length}"
 
   # 6. MODIFY EXISTING TASKS
   puts "\n6. Modifying existing tasks"
 
-  # Complete the first task
+  # Complete the first task using the done method
   operations2 = Taskchampion::Operations.new
 
   # Retrieve task fresh from storage
   task_to_complete = replica.task(uuid1)
   if task_to_complete && task_to_complete.pending?
     puts "Completing task: #{task_to_complete.description}"
-    task_to_complete.set_status(Taskchampion::Status.completed, operations2)
-    task_to_complete.set_end(Time.now, operations2)
+
+    # Use the done() method - a convenience method for marking tasks as completed
+    task_to_complete.done(operations2)
 
     # Add completion annotation
-    completion_note = Taskchampion::Annotation.new(Time.now, "Completed successfully!")
-    task_to_complete.add_annotation(completion_note, operations2)
+    task_to_complete.add_annotation("Completed successfully!", operations2)
 
     # Commit the changes
     replica.commit_operations(operations2)
-    puts "Task completed and committed"
+    puts "Task completed using done() method and committed"
+  end
+
+  # Complete the second task using traditional set_status for comparison
+  operations2b = Taskchampion::Operations.new
+  task_to_complete2 = replica.task(uuid2)
+  if task_to_complete2 && task_to_complete2.pending?
+    puts "Completing second task: #{task_to_complete2.description}"
+
+    # Alternative way: using set_status directly
+    task_to_complete2.set_status(Taskchampion::Status.completed, operations2b)
+
+    replica.commit_operations(operations2b)
+    puts "Task completed using set_status() method and committed"
   end
 
   # 7. WORKING WITH WORKING SET
@@ -233,8 +243,143 @@ begin
     end
   end
 
-  # 10. FINAL STATISTICS
-  puts "\n10. Final Statistics"
+  # 10. UPDATING TASKS WITH TASKDATA
+  puts "\n10. Updating Tasks with TaskData"
+
+  # Create a new task to demonstrate TaskData updates
+  operations_update = Taskchampion::Operations.new
+  update_uuid = SecureRandom.uuid
+
+  puts "Creating task for TaskData update demo: #{update_uuid}"
+
+  # Create task using TaskData (low-level API)
+  task_data = Taskchampion::TaskData.create(update_uuid, operations_update)
+
+  # Set initial properties using TaskData
+  task_data.update("description", "Task for update demo", operations_update)
+  task_data.update("status", "pending", operations_update)
+  task_data.update("priority", "L", operations_update) # Low priority
+  task_data.update("project", "examples", operations_update)
+
+  # Commit initial task
+  replica.commit_operations(operations_update)
+  puts "Initial task created with TaskData API"
+
+  # Retrieve and display initial task
+  initial_task_data = replica.task_data(update_uuid)
+  if initial_task_data
+    puts "Initial task properties:"
+    initial_task_data.properties.each do |prop|
+      puts "  #{prop}: #{initial_task_data.get(prop)}"
+    end
+  end
+
+  # Update the task with new properties
+  update_operations = Taskchampion::Operations.new
+  retrieved_task_data = replica.task_data(update_uuid)
+
+  if retrieved_task_data
+    puts "\nUpdating task properties..."
+
+    # Update existing properties
+    retrieved_task_data.update("description", "Updated task description", update_operations)
+    retrieved_task_data.update("priority", "M", update_operations) # Medium priority
+
+    # Add new properties
+    retrieved_task_data.update("tags", "example,taskdata,demo", update_operations)
+    retrieved_task_data.update("estimate", "2h", update_operations)
+    retrieved_task_data.update("modified", Time.now.to_i.to_s, update_operations)
+
+    # Remove a property by setting it to nil
+    retrieved_task_data.update("project", nil, update_operations)
+
+    # Commit updates
+    replica.commit_operations(update_operations)
+    puts "Task updated successfully"
+
+    # Display updated task
+    updated_task_data = replica.task_data(update_uuid)
+    if updated_task_data
+      puts "Updated task properties:"
+      updated_task_data.properties.each do |prop|
+        puts "  #{prop}: #{updated_task_data.get(prop)}"
+      end
+
+      puts "Task hash representation:"
+      puts "  #{updated_task_data.to_hash}"
+    end
+  end
+
+  # 11. DELETING TASKS WITH TASKDATA
+  puts "\n11. Deleting Tasks with TaskData"
+
+  # Create a task specifically for deletion demo
+  delete_operations = Taskchampion::Operations.new
+  delete_uuid = SecureRandom.uuid
+
+  puts "Creating task for deletion demo: #{delete_uuid}"
+
+  # Create task to be deleted
+  deletable_task_data = Taskchampion::TaskData.create(delete_uuid, delete_operations)
+  deletable_task_data.update("description", "Task to be deleted", delete_operations)
+  deletable_task_data.update("status", "completed", delete_operations)
+  deletable_task_data.update("note", "This task will be deleted", delete_operations)
+
+  # Commit the task
+  replica.commit_operations(delete_operations)
+  puts "Task created for deletion"
+
+  # Verify task exists
+  before_delete = replica.task_data(delete_uuid)
+  if before_delete
+    puts "Task exists before deletion:"
+    puts "  Description: #{before_delete.get('description')}"
+    puts "  Status: #{before_delete.get('status')}"
+    puts "  Note: #{before_delete.get('note')}"
+    puts "  Properties: #{before_delete.properties.join(', ')}"
+  else
+    puts "ERROR: Task not found before deletion"
+  end
+
+  # Delete the task using TaskData.delete
+  final_delete_operations = Taskchampion::Operations.new
+  task_to_delete = replica.task_data(delete_uuid)
+
+  if task_to_delete
+    puts "\nDeleting task..."
+    task_to_delete.delete(final_delete_operations)
+
+    # Commit the deletion
+    replica.commit_operations(final_delete_operations)
+    puts "Task deletion committed"
+
+    # Verify task is deleted
+    after_delete = replica.task_data(delete_uuid)
+    if after_delete.nil?
+      puts "✓ Task successfully deleted - no longer exists in database"
+    else
+      puts "✗ Task still exists after deletion attempt"
+    end
+
+    # Also verify it's not in the task list
+    remaining_uuids = replica.task_uuids
+    if remaining_uuids.include?(delete_uuid)
+      puts "✗ Task UUID still found in task list"
+    else
+      puts "✓ Task UUID removed from task list"
+    end
+  else
+    puts "ERROR: Could not retrieve task for deletion"
+  end
+
+  # Show difference between task deletion and status update
+  puts "\nNote: TaskData.delete() completely removes the task from the database."
+  puts "This is different from setting status to 'deleted', which keeps the task"
+  puts "but marks it as deleted. Use TaskData.delete() when you want to permanently"
+  puts "purge a task and all its data."
+
+  # 12. FINAL STATISTICS
+  puts "\n12. Final Statistics"
 
   # Refresh task list
   final_uuids = replica.task_uuids

data/examples/sync_workflow.rb

@@ -231,10 +231,10 @@ begin
     begin
       replica.sync_to_local(server_dir, avoid_snapshots: false)
       puts "  ✓ Post-work sync completed"
-      return true
+      true
     rescue => e
       puts "  ✗ Post-work sync failed: #{e.message}"
-      return false
+      false
     end
   end
 

data/ext/taskchampion/Cargo.toml

@@ -11,7 +11,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 magnus = { version = "0.7", features = ["rb-sys"] }
-rb-sys = "0.9"
+rb-sys = "0.9.103"
 taskchampion = "2.0"
 chrono = "0.4"
 uuid = "1.0"

data/ext/taskchampion/src/lib.rs

@@ -8,6 +8,7 @@ mod status;
 mod tag;
 mod annotation;
 mod task;
+mod task_data;
 mod operation;
 mod operations;
 mod replica;
@@ -31,6 +32,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     tag::init(&module)?;
     annotation::init(&module)?;
     task::init(&module)?;
+    task_data::init(&module)?;
     operation::init(&module)?;
     operations::init(&module)?;
     working_set::init(&module)?;

data/ext/taskchampion/src/replica.rs

@@ -6,6 +6,7 @@ use taskchampion::{Replica as TCReplica, ServerConfig, StorageConfig};
 use crate::access_mode::AccessMode;
 use crate::operations::Operations;
 use crate::task::Task;
+use crate::task_data::TaskData;
 use crate::working_set::WorkingSet;
 use crate::dependency_map::DependencyMap;
 use crate::thread_check::ThreadBound;
@@ -77,7 +78,7 @@ impl Replica {
         Ok(())
     }
 
-    fn tasks(&self) -> Result<RHash, Error> {
+    fn all_tasks(&self) -> Result<RHash, Error> {
         let mut tc_replica = self.0.get_mut()?;
 
         let tasks = tc_replica.all_tasks().map_err(into_error)?;
@@ -99,9 +100,9 @@ impl Replica {
             .get_task_data(uuid2tc(&uuid)?)
             .map_err(into_error)?;
 
-        option_to_ruby(task_data, |_data| {
-            // TODO: Convert task data to Ruby TaskData object
-            Ok(().into_value()) // () converts to nil in Magnus
+        option_to_ruby(task_data, |data| {
+            let ruby_task_data = TaskData::from_tc_task_data(data);
+            Ok(ruby_task_data.into_value())
         })
     }
 
@@ -271,7 +272,7 @@ pub fn init(module: &RModule) -> Result<(), Error> {
     // Instance methods
     class.define_method("create_task", method!(Replica::create_task, 2))?;
     class.define_method("commit_operations", method!(Replica::commit_operations, 1))?;
-    class.define_method("tasks", method!(Replica::tasks, 0))?;
+    class.define_method("all_tasks", method!(Replica::all_tasks, 0))?;
     class.define_method("task", method!(Replica::task, 1))?;
     class.define_method("task_data", method!(Replica::task_data, 1))?;
     class.define_method("task_uuids", method!(Replica::task_uuids, 0))?;

data/ext/taskchampion/src/task.rs

@@ -7,7 +7,7 @@ use crate::annotation::Annotation;
 use crate::status::Status;
 use crate::tag::Tag;
 use crate::thread_check::ThreadBound;
-use crate::util::{datetime_to_ruby, into_error, option_to_ruby, ruby_to_datetime, ruby_to_option, vec_to_ruby};
+use crate::util::{datetime_to_ruby, option_to_ruby, ruby_to_datetime, ruby_to_option, vec_to_ruby};
 
 #[magnus::wrap(class = "Taskchampion::Task", free_immediately)]
 pub struct Task(ThreadBound<TCTask>);
@@ -326,6 +326,14 @@ impl Task {
         Ok(())
     }
 
+    fn done(&self, operations: &crate::operations::Operations) -> Result<(), Error> {
+        let mut task = self.0.get_mut()?;
+        operations.with_inner_mut(|ops| {
+            task.done(ops)
+        })?;
+        Ok(())
+    }
+
 }
 
 // Remove AsRef implementation as it doesn't work well with thread bounds
@@ -384,5 +392,6 @@ pub fn init(module: &RModule) -> Result<(), Error> {
     class.define_method("set_value", method!(Task::set_value, 3))?;
     class.define_method("set_uda", method!(Task::set_uda, 4))?;
     class.define_method("delete_uda", method!(Task::delete_uda, 3))?;
+    class.define_method("done", method!(Task::done, 1))?;
     Ok(())
 }

data/ext/taskchampion/src/task_data.rs

@@ -0,0 +1,122 @@
+use magnus::{
+    class, function, method, prelude::*, Error, IntoValue, RArray, RHash, RModule, Value,
+};
+use taskchampion::TaskData as TCTaskData;
+
+use crate::operations::Operations;
+use crate::thread_check::ThreadBound;
+use crate::util::{option_to_ruby, uuid2tc, vec_to_ruby};
+
+#[magnus::wrap(class = "Taskchampion::TaskData", free_immediately)]
+pub struct TaskData(ThreadBound<TCTaskData>);
+
+impl TaskData {
+    pub fn from_tc_task_data(tc_task_data: TCTaskData) -> Self {
+        TaskData(ThreadBound::new(tc_task_data))
+    }
+    fn inspect(&self) -> Result<String, Error> {
+        let task_data = self.0.get()?;
+        Ok(format!("#<Taskchampion::TaskData: {}>", task_data.get_uuid()))
+    }
+
+    fn uuid(&self) -> Result<String, Error> {
+        let task_data = self.0.get()?;
+        Ok(task_data.get_uuid().to_string())
+    }
+
+    fn get(&self, property: String) -> Result<Value, Error> {
+        let task_data = self.0.get()?;
+        option_to_ruby(task_data.get(&property), |s| Ok(s.into_value()))
+    }
+
+    fn has(&self, property: String) -> Result<bool, Error> {
+        let task_data = self.0.get()?;
+        Ok(task_data.has(&property))
+    }
+
+    fn properties(&self) -> Result<RArray, Error> {
+        let task_data = self.0.get()?;
+        let props: Vec<String> = task_data.properties().cloned().collect();
+        vec_to_ruby(props, |s| Ok(s.into_value()))
+    }
+
+    fn to_hash(&self) -> Result<RHash, Error> {
+        let task_data = self.0.get()?;
+        let hash = RHash::new();
+
+        for (key, value) in task_data.iter() {
+            hash.aset(key.clone(), value.clone())?;
+        }
+
+        Ok(hash)
+    }
+
+    fn update(&self, property: String, value: Value, operations: &Operations) -> Result<(), Error> {
+        if property.trim().is_empty() {
+            return Err(Error::new(
+                crate::error::validation_error(),
+                "Property name cannot be empty or whitespace-only"
+            ));
+        }
+
+        let mut task_data = self.0.get_mut()?;
+        let value_str = if value.is_nil() {
+            None
+        } else {
+            Some(value.to_string())
+        };
+
+        operations.with_inner_mut(|ops| {
+            task_data.update(&property, value_str, ops);
+            Ok(())
+        })?;
+
+        Ok(())
+    }
+
+    fn delete(&self, operations: &Operations) -> Result<(), Error> {
+        let mut task_data = self.0.get_mut()?;
+
+        operations.with_inner_mut(|ops| {
+            task_data.delete(ops);
+            Ok(())
+        })?;
+
+        Ok(())
+    }
+}
+
+fn create_task_data(uuid: String, operations: &Operations) -> Result<TaskData, Error> {
+    let tc_uuid = uuid2tc(&uuid)?;
+
+    // Create operations for TaskChampion
+    let mut tc_ops = taskchampion::Operations::new();
+
+    // Create the TaskData
+    let tc_task_data = TCTaskData::create(tc_uuid, &mut tc_ops);
+
+    // Add the resulting operations to the provided Operations object
+    operations.extend_from_tc(tc_ops.into_iter().collect())?;
+
+    Ok(TaskData(ThreadBound::new(tc_task_data)))
+}
+
+pub fn init(module: &RModule) -> Result<(), Error> {
+    let class = module.define_class("TaskData", class::object())?;
+
+    // Class methods
+    class.define_singleton_method("create", function!(create_task_data, 2))?;
+
+    // Instance methods
+    class.define_method("inspect", method!(TaskData::inspect, 0))?;
+    class.define_method("uuid", method!(TaskData::uuid, 0))?;
+    class.define_method("get", method!(TaskData::get, 1))?;
+    class.define_method("has?", method!(TaskData::has, 1))?;
+    class.define_method("properties", method!(TaskData::properties, 0))?;
+    class.define_method("to_hash", method!(TaskData::to_hash, 0))?;
+    class.define_method("to_h", method!(TaskData::to_hash, 0))?;
+    class.define_method("update", method!(TaskData::update, 3))?;
+    class.define_method("delete", method!(TaskData::delete, 1))?;
+
+    Ok(())
+}

data/ext/taskchampion/src/util.rs

@@ -45,21 +45,34 @@ pub fn ruby_to_datetime(value: Value) -> Result<DateTime<Utc>, Error> {
                 format!("Invalid datetime format: '{}'. Expected ISO 8601 format (e.g., '2023-01-01T12:00:00Z') or '%Y-%m-%d %H:%M:%S %z'", s)
             ))
     } else {
-        // Convert Ruby DateTime/Time to ISO string then parse
-        match value.funcall::<_, (), String>("iso8601", ()) {
-            Ok(iso_string) => {
-                DateTime::parse_from_rfc3339(&iso_string)
-                    .map(|dt| dt.with_timezone(&Utc))
-                    .map_err(|_| Error::new(
-                        validation_error(),
-                        format!("Invalid datetime from Ruby object: '{}'. Unable to parse as ISO 8601", iso_string)
-                    ))
+        // Check if it's a Time object first (Time doesn't have iso8601 method)
+        let class = value.class();
+        let class_name = unsafe { class.name() };
+        let iso_string = if class_name == "Time" {
+            // For Time objects, use strftime to get ISO 8601-like format
+            value.funcall::<_, (&str,), String>("strftime", ("%Y-%m-%dT%H:%M:%S%z",))?
+        } else {
+            // For DateTime objects, use iso8601 method
+            match value.funcall::<_, (), String>("iso8601", ()) {
+                Ok(s) => s,
+                Err(_) => return Err(Error::new(
+                    validation_error(),
+                    format!("Cannot convert value to datetime. Expected Time, DateTime, or String, got: {}", class_name)
+                ))
             }
-            Err(_) => Err(Error::new(
+        };
+
+        DateTime::parse_from_rfc3339(&iso_string)
+            .map(|dt| dt.with_timezone(&Utc))
+            .or_else(|_| {
+                // Try parsing the Time strftime format (%z gives +HHMM instead of +HH:MM)
+                DateTime::parse_from_str(&iso_string, "%Y-%m-%dT%H:%M:%S%z")
+                    .map(|dt| dt.with_timezone(&Utc))
+            })
+            .map_err(|_| Error::new(
                 validation_error(),
-                format!("Cannot convert value to datetime. Expected Time, DateTime, or String, got: {}", value.class().inspect())
+                format!("Invalid datetime from Ruby object: '{}'. Unable to parse as ISO 8601", iso_string)
             ))
-        }
     }
 }
 

data/lib/taskchampion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Taskchampion
-  VERSION = "0.2.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: taskchampion-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Tim Case
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -32,8 +33,8 @@ extensions:
 - ext/taskchampion/extconf.rb
 extra_rdoc_files: []
 files:
-- ".claude/settings.local.json"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - Cargo.lock
 - Cargo.toml
@@ -61,13 +62,12 @@ files:
 - ext/taskchampion/src/status.rs
 - ext/taskchampion/src/tag.rs
 - ext/taskchampion/src/task.rs
+- ext/taskchampion/src/task_data.rs
 - ext/taskchampion/src/thread_check.rs
 - ext/taskchampion/src/util.rs
 - ext/taskchampion/src/working_set.rs
 - lib/taskchampion.rb
 - lib/taskchampion/version.rb
-- sig/taskchampion.rbs
-- taskchampion-0.2.0.gem
 homepage: https://github.com/timcase/taskchampion-rb
 licenses:
 - MIT
@@ -76,6 +76,7 @@ metadata:
   homepage_uri: https://github.com/timcase/taskchampion-rb
   source_code_uri: https://github.com/timcase/taskchampion-rb
   changelog_uri: https://github.com/timcase/taskchampion-rb/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,7 +91,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: Ruby bindings for TaskChampion
 test_files: []

data/.claude/settings.local.json

@@ -1,14 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(bundle exec rake:*)",
-      "mcp__zen__chat",
-      "mcp__zen__thinkdeep",
-      "WebFetch(domain:github.com)",
-      "WebFetch(domain:docs.taskwarrior.org)",
-      "Bash(chmod:*)",
-      "Bash(gem build:*)"
-    ],
-    "deny": []
-  }
-}

data/sig/taskchampion.rbs

@@ -1,4 +0,0 @@
-module Taskchampion
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end