agentilda 1.0.3 → 2.0.0

data/lib/agentilda/cli/linear/subcommands/import.rb

@@ -8,18 +8,26 @@ module Agentilda
       class Import < Team
         desc "Create Linear issues from the plans: one per folder, one child per work unit"
 
-        option :project, aliases: ["-p", "--project-url", "--project-id"],
-          desc: "The project to file everything under: its URL, its name, or its id"
-        option :commit, type: :boolean, default: false,
-          desc: "Actually create and update in Linear (default: dry run)"
-        option :format, default: "text", values: %w[text json],
-          desc: "json emits the exact arguments the Linear MCP tools take"
-        option :since, aliases: ["-s"],
-          desc: "Skip plans numbered below this, e.g. 010.00"
+        option :project,
+          aliases: ["-p", "--project-url", "--project-id"],
+          desc:    "The project to file everything under: its URL, its name, or its id"
+        option :commit,
+          type:    :boolean,
+          default: false,
+          desc:    "Actually create and update in Linear (default: dry run)"
+        option :format,
+          default: "text",
+          values:  %w[text json],
+          desc:    "json emits the exact arguments the Linear MCP tools take"
+        option :since,
+          aliases: ["-s"],
+          desc:    "Skip plans numbered below this, e.g. 010.00"
         option :status,
           desc: "Only plans in these states: a comma-separated list of status keys"
-        option :force, type: :boolean, default: false,
-          desc: "Update everything, whether the plan has changed or not"
+        option :force,
+          type:    :boolean,
+          default: false,
+          desc:    "Update everything, whether the plan has changed or not"
 
         example [
           "TAX -p 'US Tax Law: Self Contained Ruby Gem'   # show what would be created",
@@ -61,7 +69,7 @@ module Agentilda
         def resolve_project(team, tree, options)
           reference = options[:project].to_s
           looks_up = reference.match?(%r{\Ahttps?://}) || reference.match?(/\A[0-9a-f-]{32,}\z/)
-          return {"id" => nil, "name" => reference, "url" => nil} if !looks_up && offline?
+          return { "id" => nil, "name" => reference, "url" => nil } if !looks_up && offline?
 
           _api, survey = survey_for(team, tree)
           survey.project(reference)
@@ -84,8 +92,11 @@ module Agentilda
 
         # @return [Agentilda::Linear::Import]
         def build(tree, team, project, options)
-          Agentilda::Linear::Import.new(tree:, team: Agentilda::Linear.key!(team), project:,
-            since: options[:since], statuses: statuses(options),
+          Agentilda::Linear::Import.new(tree:,
+            team: Agentilda::Linear.key!(team),
+            project:,
+            since: options[:since],
+            statuses: statuses(options),
             force: options.fetch(:force, false))
         end
 
@@ -116,13 +127,13 @@ module Agentilda
         # @return [String]
         def row(action)
           [action.op, action.kind, action.ordinal, action.unit || "-",
-            action.identifier || "-", action.title].join("\t")
+           action.identifier || "-", action.title].join("\t")
         end
 
         # @param action [Agentilda::Linear::Action]
         # @return [String]
         def line(action)
-          verb = paint(action.op.to_s.ljust(6), (action.op == :create) ? :green : :yellow)
+          verb = paint(action.op.to_s.ljust(6), action.op == :create ? :green : :yellow)
           indent = action.child? ? "    " : ""
           "#{verb} #{indent}#{action.title}  #{paint("(#{action.reason})", :bright_black)}"
         end

data/lib/agentilda/cli/mail/mail.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Agentilda
+  module CLI
+    # `agentilda mail` — the two halves of a pair talking through the plan
+    # folder. See {Agentilda::Mailbox} for why a file rather than a session.
+    module Mail
+      # Both subcommands name a plan and need its folder.
+      module Locating
+        private
+
+        # An unknown number is refused rather than given an empty mailbox:
+        # an agent polling the wrong plan for a whole round would read
+        # silence as "my partner has nothing to say".
+        #
+        # @param options [Hash]
+        # @return [Agentilda::Mailbox]
+        def mailbox_for(options)
+          tree = tree_for(options)
+          ordinal = Ordinal.parse(options[:plan].to_s)
+          subject = ordinal && tree.find(ordinal)
+          unless subject
+            refuse("No plan #{options[:plan]} in #{tree.dir}.\n\nKnown: #{tree.ordinals.join(", ")}", 66)
+          end
+
+          Mailbox.new(dir: subject.feature.path)
+        end
+      end
+    end
+  end
+end

data/lib/agentilda/cli/mail/subcommands/read.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Agentilda
+  module CLI
+    module Mail
+      # `agentilda mail read` — what is waiting for one agent.
+      #
+      # Nothing waiting is the ordinary result of a poll, so it is not an
+      # error and not even STDOUT: the messages are the deliverable, and an
+      # empty one is empty.
+      class Read < Base
+        include Locating
+
+        desc "Print the messages waiting for an agent in a plan's mailbox"
+
+        option :plan, required: true, desc: "Which plan: NNN or NNN.MM"
+        option :for, required: true, desc: "The agent reading"
+        option :after, default: "0", desc: "Only messages numbered above this, so a poll shows what is new"
+
+        example [
+          "--plan 003 --for rey-frontend            # everything addressed to rey",
+          "--plan 003 --for rey-frontend --after 4  # only what arrived since #4"
+        ]
+
+        # @param options [Hash]
+        # @return [void]
+        def call(**options)
+          quiet?(options)
+          mailbox = mailbox_for(options)
+          after = options[:after].to_i
+          waiting = mailbox.for(options[:for], after:)
+
+          if waiting.empty?
+            UI.line("Nothing for #{options[:for]}#{" after ##{after}" if after.positive?}") unless quiet?(options)
+            return
+          end
+
+          puts waiting.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/agentilda/cli/mail/subcommands/send.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Agentilda
+  module CLI
+    module Mail
+      # `agentilda mail send` — leave a message for the other half.
+      class Send < Base
+        include Locating
+
+        desc "Append a message to a plan's mailbox"
+
+        argument :body, type: :string, required: true, desc: "The message, quoted"
+
+        option :plan, required: true, desc: "Which plan: NNN or NNN.MM"
+        option :from, required: true, desc: "The agent writing"
+        option :to, required: true, desc: "The agent it is for"
+
+        example [
+          %(--plan 003 --from luke-backend --to rey-frontend "GET /returns/:id is up; errors come back as {error: {code, message}}")
+        ]
+
+        # @param body [String]
+        # @param options [Hash]
+        # @return [void]
+        def call(body:, **options)
+          quiet?(options)
+          mailbox = mailbox_for(options)
+          message = begin
+            mailbox.append(from: options[:from], to: options[:to], body:)
+          rescue Agentilda::Error => e
+            refuse(e.message, 64)
+          end
+
+          return if quiet?(options)
+
+          # One line, not a box: an agent runs this between steps, and a
+          # four-line frame around "#7 → rey-frontend" is noise it reads.
+          UI.line("##{message.number} → #{message.to}, in #{File.basename(mailbox.dir)}/#{Mailbox::FILENAME}")
+        end
+      end
+    end
+  end
+end

data/lib/agentilda/cli/resync/subcommands/dirs.rb

@@ -8,8 +8,10 @@ module Agentilda
       class Dirs < Base
         desc "Rename plan folders so the name matches the contents and the NNN.MM form"
 
-        option :commit, type: :boolean, default: false,
-          desc: "Actually rename the folders (default: dry run)"
+        option :commit,
+          type:    :boolean,
+          default: false,
+          desc:    "Actually rename the folders (default: dry run)"
 
         example [
           "                # show what would be renamed",
@@ -20,10 +22,10 @@ module Agentilda
         # @return [void]
         def call(**options)
           changes = Agentilda::Resync::Dirs.new(tree: tree_for(options))
-            .call(commit: commit?(options))
+                                           .call(commit: commit?(options))
 
           if changes.empty?
-            success("Every folder is already named NNN.MM-<emoji>-<slug> and the emoji matches.") unless quiet?(options)
+            success("Every folder is already named NNN.MM-<emoji> → <slug> and the emoji matches.") unless quiet?(options)
             return
           end
 

data/lib/agentilda/cli/resync/subcommands/prs.rb

@@ -8,12 +8,18 @@ module Agentilda
       class Prs < Base
         desc "Add missing [NNN.MM] prefixes to pull request titles"
 
-        option :commit, type: :boolean, default: false,
-          desc: "Actually retitle the pull requests (default: dry run)"
-        option :state, default: "all", values: %w[open closed merged all],
-          desc: "Which pull requests to consider"
-        option :adopt, type: :boolean, default: true,
-          desc: "Mint a retroactive plan folder for every pull request that resolves to none. --no-adopt flags them for a human instead"
+        option :commit,
+          type:    :boolean,
+          default: false,
+          desc:    "Actually retitle the pull requests (default: dry run)"
+        option :state,
+          default: "all",
+          values:  %w[open closed merged all],
+          desc:    "Which pull requests to consider"
+        option :adopt,
+          type:    :boolean,
+          default: true,
+          desc:    "Mint a retroactive plan folder for every pull request that resolves to none. --no-adopt flags them for a human instead"
 
         example [
           "                # show what would be retitled, and what would be adopted",
@@ -27,9 +33,11 @@ module Agentilda
         def call(**options)
           github = GitHub.new
           tree = tree_for(options)
-          changes = Agentilda::Resync::Prs.new(tree:, github:,
-            adopt: options.fetch(:adopt, true), root: File.dirname(tree.dir))
-            .call(commit: commit?(options))
+          changes = Agentilda::Resync::Prs.new(tree:,
+            github:,
+            adopt: options.fetch(:adopt, true),
+            root: File.dirname(tree.dir))
+                                          .call(commit: commit?(options))
 
           if changes.empty?
             success("Every pull request title already carries a prefix.") unless quiet?(options)
@@ -58,10 +66,10 @@ module Agentilda
 
           applicable.each do |c|
             note = if c.adopted?
-              paint("   (new plan)", :magenta)
-            elsif c.assumed?
-              paint("   (assumed)", :yellow)
-            end
+                     paint("   (new plan)", :magenta)
+                   elsif c.assumed?
+                     paint("   (assumed)", :yellow)
+                   end
             say("##{c.number}  #{c.new_title}#{note}")
           end