brainiac 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab0a2720abc8e0ea7c76d7a0c4f8ec6303a744dc8bdf7dfd6cd7d41b5d0671e2
-  data.tar.gz: beefb425e88f3418babaf504b5d0a4841c7d7cda03ef189951adb1fd42c747fd
+  metadata.gz: cedcfe4e4dfa26034cf0ded9746d8ff5bade886ec3d83774580d8334777d4d3c
+  data.tar.gz: 96d1702d994f06f0a4f41870de6652258fc700a9f9df1b6193c347b2cce3b365
 SHA512:
-  metadata.gz: 30ed5d2c72453ef0bf624c1bf34df92111bd1e5cab30c492fc483ad9ab241794ff177452b2bbc533e42d39b9199882382eda6930acc89a83f8f3a371020cd166
-  data.tar.gz: b5d1b984a1bf7e17e094da496b831f34c822c9368a1c8966b6dc3d30057101c913d69629cf94f9358b6ee196d4a84dd58fb744fe8d652f5280dbf344911efc2f
+  metadata.gz: 16a5c9937e67afe78bcba468dea8a4b75c73864c4a320b8d2da930a966bd618797b6285f765f772a99394d8925ba9438fe2b9012ccb94730908e97642148cdbb
+  data.tar.gz: 95cd9275779731da352b0356e1da275f12511b960037512e829614a6b5e2a4a97e3b00ba0ceeefbdbcc8eff71a3f0717b9cc43fb3ee4d21b2b706361e4dfccc0

data/lib/brainiac/helpers.rb

@@ -107,9 +107,8 @@ end
 # Returns the provider name (e.g. "grok") or nil.
 def detect_cli_provider(text: "", tags: [])
   # Inline tag: [cli:grok] — works in any channel
-  if (match = text.match(/\[cli:(\w+)\]/i))
-    return match[1].downcase
-  end
+  inline = inline_cli_provider_tag(text)
+  return inline if inline
 
   # Plugin hook: let plugins detect from their own metadata (e.g., card tags)
   results = Brainiac.emit(:detect_cli_provider, text: text, tags: tags)
@@ -119,6 +118,11 @@ def detect_cli_provider(text: "", tags: [])
   nil
 end
 
+# The provider named by an inline [cli:X] tag in text, or nil. Text only — no plugin hooks.
+def inline_cli_provider_tag(text)
+  text.to_s.match(/\[cli:(\w+)\]/i)&.[](1)&.downcase
+end
+
 def default_project_key
   # Find the project marked as default
   default = PROJECTS.find { |_key, config| config["default"] == true }
@@ -354,9 +358,11 @@ def register_work_item(branch:, worktree: nil, project: nil, agent: nil, source:
 end
 
 # Update dispatch overrides on a work item (cli_provider, model, effort, profile).
-# Only non-nil values are stored; nil values are removed from existing overrides.
+# Non-nil values are stored; nil values leave the existing override untouched.
+# Keys listed in clear: (e.g. [:model]) are removed from the stored overrides.
 # Returns true if the work item was found and updated, false otherwise.
-def update_work_item_overrides(cli_provider: nil, model: nil, effort: nil, profile: nil, work_item_id: nil, branch: nil) # rubocop:disable Naming/PredicateMethod
+def update_work_item_overrides(cli_provider: nil, model: nil, effort: nil, profile: nil, work_item_id: nil, branch: nil, # rubocop:disable Naming/PredicateMethod
+                               clear: [])
   map = load_work_item_map
 
   target_id = work_item_id
@@ -376,6 +382,7 @@ def update_work_item_overrides(cli_provider: nil, model: nil, effort: nil, profi
   overrides["model"] = model if model
   overrides["effort"] = effort if effort
   overrides["profile"] = profile if profile
+  Array(clear).each { |key| overrides.delete(key.to_s) }
   overrides.compact!
 
   if overrides.empty?
@@ -425,33 +432,78 @@ end
 # Unknown profile names are never persisted, so a typo can't pin a work item to a
 # profile that doesn't exist (profile_spawn_env ignores it for this dispatch too).
 #
+# A stored model is a provider-specific ID (kiro's "opus" is "claude-opus-4.5", claude's is
+# "opus"), so switching providers with [cli:X] drops it and the new provider's default
+# applies, unless the same message also carries a model tag. default_cli_provider: is the
+# provider a work item with no stored cli_provider was running on; without it, any inline
+# [cli:X] on such a work item counts as a switch.
+#
 # Returns: { cli_provider:, model:, effort:, profile: } (each String or nil)
 def resolve_work_item_overrides(work_item_id: nil, branch: nil, inline_cli_provider: nil, inline_model: nil, inline_effort: nil,
-                                inline_profile: nil)
+                                inline_profile: nil, default_cli_provider: nil)
   stored = work_item_overrides_for(work_item_id: work_item_id, branch: branch)
   inline_profile = inline_profile&.to_s&.downcase
   persist_profile = inline_profile && profile_entry(inline_profile) ? inline_profile : nil
+  switched = cli_provider_switched?(inline_cli_provider, stored["cli_provider"] || default_cli_provider)
+  stored_model = switched ? nil : stored["model"]
 
   # Inline tags override stored values
   resolved = {
     cli_provider: inline_cli_provider || stored["cli_provider"],
-    model: inline_model || stored["model"],
+    model: inline_model || stored_model,
     effort: inline_effort || stored["effort"],
     profile: inline_profile || stored["profile"]
   }
 
   # Persist any new inline overrides to the work item for future dispatches
-  new_overrides = {}
-  new_overrides[:cli_provider] = inline_cli_provider if inline_cli_provider
-  new_overrides[:model] = inline_model if inline_model
-  new_overrides[:effort] = inline_effort if inline_effort
-  new_overrides[:profile] = persist_profile if persist_profile
+  new_overrides = { cli_provider: inline_cli_provider, model: inline_model, effort: inline_effort,
+                    profile: persist_profile }.compact
+  new_overrides[:clear] = [:model] if switched && !inline_model && stored["model"]
 
   update_work_item_overrides(work_item_id: work_item_id, branch: branch, **new_overrides) if new_overrides.any? && (work_item_id || branch)
 
   resolved
 end
 
+# True when an inline [cli:X] names a different provider than the one previously in use.
+def cli_provider_switched?(inline_cli_provider, previous_cli_provider)
+  !inline_cli_provider.nil? && inline_cli_provider != previous_cli_provider
+end
+
+# One-stop override resolution for a dispatch: parses [cli:X]/[model]/[effort:X]/[p:X] from
+# the message text (and plugin card tags), merges them with the work item's stored overrides,
+# and persists any new inline values. The model and effort are resolved against the provider
+# that will actually run (inline > stored > agent/project default), so a [sonnet] tag can't be
+# looked up in the wrong provider's model map. Plugins should prefer this over calling
+# detect_model/detect_effort and resolve_work_item_overrides by hand.
+#
+# Returns: { cli_provider:, model:, explicit_model:, effort:, profile: }
+#   cli_provider is nil when nothing overrides the agent/project default.
+#   explicit_model is true when the model came from a tag (see detect_model_explicit).
+def resolve_dispatch_overrides(project_config, text: "", tags: [], agent_name: nil, work_item_id: nil, branch: nil)
+  stored = work_item_overrides_for(work_item_id: work_item_id, branch: branch)
+  inline_cli = detect_cli_provider(text: text, tags: tags)
+  default_cli = agent_cli_provider_for(agent_name) || project_config["cli_provider"]
+  effective_cli = inline_cli || stored["cli_provider"]
+
+  model, explicit_model = detect_model_explicit(project_config, tags: tags, text: text,
+                                                                cli_provider_override: effective_cli, agent_name: agent_name)
+  effort, explicit_effort = detect_effort_explicit(project_config, tags: tags, text: text,
+                                                                   cli_provider_override: effective_cli, agent_name: agent_name)
+
+  resolved = resolve_work_item_overrides(work_item_id: work_item_id, branch: branch, inline_cli_provider: inline_cli,
+                                         inline_model: explicit_model ? model : nil,
+                                         inline_effort: explicit_effort ? effort : nil,
+                                         inline_profile: detect_profile(text: text, tags: tags),
+                                         default_cli_provider: default_cli)
+  # Nothing tagged or stored (or the stored model was dropped by a switch): use the
+  # effective provider's defaults, already resolved above.
+  resolved[:model] ||= model
+  resolved[:effort] ||= effort
+  resolved[:explicit_model] = explicit_model
+  resolved
+end
+
 # Add or update a source on an existing work item.
 # Returns true if the work item was found and updated, false otherwise.
 def register_work_item_source(source:, source_data:, work_item_id: nil, branch: nil) # rubocop:disable Naming/PredicateMethod
@@ -984,7 +1036,11 @@ def append_model_to_cmd(cmd, model, resolved)
   # This handles cases where different projects use "auto" but each CLI provider maps it differently.
   effective_model = allowed.key?(model) ? allowed[model] : model
   is_known = allowed.value?(effective_model) || allowed.key?(effective_model)
-  cmd.push(resolved["agent_model_flag"], effective_model) if is_known
+  if is_known
+    cmd.push(resolved["agent_model_flag"], effective_model)
+  else
+    LOG.warn "[Model] Dropping model '#{model}': not in #{resolved["agent_cli"]}'s model map; using the CLI's default"
+  end
 end
 
 # A model is only "explicit" if the caller actually supplied one (i.e. it came from a
@@ -1344,8 +1400,9 @@ end
 # while a fell-back-to-default value must NOT write — otherwise every no-tag dispatch
 # would clobber each account's per-account default back to the project default.
 def detect_model_explicit(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
-  # If no explicit CLI provider override, check if the agent has one configured
-  effective_cli_provider = cli_provider_override || agent_cli_provider_for(agent_name)
+  # Without an explicit override, a [cli:X] in the same text picks the model map (so
+  # "[cli:claude] [sonnet]" resolves through claude's map), then the agent's provider.
+  effective_cli_provider = cli_provider_override || inline_cli_provider_tag(text) || agent_cli_provider_for(agent_name)
   resolved = resolve_project_cli_config(project_config, cli_provider_override: effective_cli_provider, agent_name: agent_name)
   allowed_models = resolved["allowed_models"] || {}
   return [resolved["agent_model"], false] if allowed_models.empty?
@@ -1368,22 +1425,29 @@ end
 # If the requested level isn't supported by the current model, returns the closest
 # lower level from allowed_efforts.
 def detect_effort(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
-  effective_cli_provider = cli_provider_override || agent_cli_provider_for(agent_name)
+  detect_effort_explicit(project_config, tags: tags, text: text,
+                                         cli_provider_override: cli_provider_override, agent_name: agent_name).first
+end
+
+# Like detect_effort, but returns [level, explicit_bool] where explicit is true only when
+# the level came from an [effort:X] tag or a plugin's card tag (not the provider default).
+def detect_effort_explicit(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
+  effective_cli_provider = cli_provider_override || inline_cli_provider_tag(text) || agent_cli_provider_for(agent_name)
   resolved = resolve_project_cli_config(project_config, cli_provider_override: effective_cli_provider, agent_name: agent_name)
   allowed = resolved["allowed_efforts"] || %w[low medium high xhigh max]
 
   # Inline tag: [effort:high] — works in any channel
   if (match = text.match(/\[effort:(\w+)\]/i))
     level = match[1].downcase
-    return resolve_effort_level(level, allowed) if allowed.include?(level)
+    return [resolve_effort_level(level, allowed), true] if allowed.include?(level)
   end
 
   # Plugin hook: let plugins detect from their own metadata (e.g., card tags)
   results = Brainiac.emit(:detect_effort, tags: tags, allowed: allowed)
   plugin_result = results.compact.first
-  return resolve_effort_level(plugin_result, allowed) if plugin_result
+  return [resolve_effort_level(plugin_result, allowed), true] if plugin_result
 
-  resolved["agent_effort"]
+  [resolved["agent_effort"], false]
 end
 
 # Detect a profile ([profile:X]/[p:X]) from inline text OR card tags.

data/lib/brainiac/version.rb

@@ -2,5 +2,5 @@
 
 module Brainiac
   # @return [String] the current gem version
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Andy Davis