rubik 0.12.0 → 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (107) hide show
  1. checksums.yaml +4 -4
  2. data/ATTRIBUTION.md +1 -1
  3. data/CHANGELOG.md +71 -1
  4. data/bin/rubik +11 -1
  5. data/lib/rubik/ast/c_extractor.rb +1 -1
  6. data/lib/rubik/ast/graph.rb +38 -57
  7. data/lib/rubik/ast/graph_extensions.rb +57 -15
  8. data/lib/rubik/ast/ruby_extractor.rb +4 -0
  9. data/lib/rubik/ast/treesitter/c_walker.rb +11 -3
  10. data/lib/rubik/buffer/manager.rb +33 -11
  11. data/lib/rubik/buffer/snapshot.rb +23 -3
  12. data/lib/rubik/cli/connect.rb +49 -0
  13. data/lib/rubik/config/defaults.rb +4 -7
  14. data/lib/rubik/config/env_guard.rb +43 -0
  15. data/lib/rubik/config/schema.rb +8 -1
  16. data/lib/rubik/config/secret_policy.rb +6 -5
  17. data/lib/rubik/config.rb +1 -1
  18. data/lib/rubik/connect/http.rb +85 -0
  19. data/lib/rubik/connect/models_dev.rb +173 -0
  20. data/lib/rubik/connect/probes.rb +103 -0
  21. data/lib/rubik/connect/prompt_ui.rb +139 -0
  22. data/lib/rubik/connect/wizard.rb +540 -0
  23. data/lib/rubik/connect.rb +7 -0
  24. data/lib/rubik/context/repo_context_reader.rb +8 -4
  25. data/lib/rubik/llm/chunk_assembler.rb +12 -1
  26. data/lib/rubik/llm/formatter.rb +14 -0
  27. data/lib/rubik/llm/openai_compatible.rb +4 -1
  28. data/lib/rubik/llm/provider_key.rb +32 -0
  29. data/lib/rubik/llm/registry.rb +18 -2
  30. data/lib/rubik/llm/router.rb +19 -1
  31. data/lib/rubik/llm/session_header.rb +128 -0
  32. data/lib/rubik/llm/sse_parser.rb +57 -10
  33. data/lib/rubik/lsp/client.rb +11 -5
  34. data/lib/rubik/lsp/transport.rb +17 -7
  35. data/lib/rubik/mcp/transport/stdio.rb +42 -4
  36. data/lib/rubik/orchestrator/continuation_manager.rb +14 -5
  37. data/lib/rubik/orchestrator/goal_ledger/ledger.rb +18 -2
  38. data/lib/rubik/orchestrator/goal_ledger/observation_projection.rb +13 -4
  39. data/lib/rubik/orchestrator/goal_ledger/validator.rb +46 -7
  40. data/lib/rubik/orchestrator/goal_ledger/verifier.rb +8 -1
  41. data/lib/rubik/orchestrator/goal_session.rb +4 -4
  42. data/lib/rubik/orchestrator/loop.rb +8 -11
  43. data/lib/rubik/orchestrator/provider_resolver.rb +29 -6
  44. data/lib/rubik/orchestrator/step_executor.rb +17 -2
  45. data/lib/rubik/orchestrator/subagent/instance.rb +24 -1
  46. data/lib/rubik/orchestrator/subagent/notices.rb +1 -1
  47. data/lib/rubik/orchestrator/subagent/reaper.rb +21 -2
  48. data/lib/rubik/orchestrator/subagent/start_gate.rb +1 -1
  49. data/lib/rubik/orchestrator/subagent/step_runner.rb +7 -7
  50. data/lib/rubik/orchestrator/subagent/supervisor.rb +10 -3
  51. data/lib/rubik/orchestrator/turn_executor/user_channel.rb +27 -5
  52. data/lib/rubik/orchestrator/turn_executor.rb +24 -8
  53. data/lib/rubik/platform/filesystem.rb +52 -24
  54. data/lib/rubik/plugin/storage.rb +20 -0
  55. data/lib/rubik/prompt/context_builder.rb +2 -1
  56. data/lib/rubik/repair/loop.rb +22 -2
  57. data/lib/rubik/repl/commands/agent_context.rb +1 -1
  58. data/lib/rubik/repl/commands/agent_execution.rb +20 -15
  59. data/lib/rubik/repl/commands/buffer.rb +15 -0
  60. data/lib/rubik/repl/commands/connect.rb +51 -0
  61. data/lib/rubik/repl/commands/lsp.rb +1 -1
  62. data/lib/rubik/repl/commands/plugins.rb +31 -31
  63. data/lib/rubik/repl/commands/session.rb +5 -5
  64. data/lib/rubik/repl/commands/workspace.rb +4 -4
  65. data/lib/rubik/repl/commands.rb +2 -0
  66. data/lib/rubik/repl/input_execution.rb +30 -29
  67. data/lib/rubik/repl/input_loop.rb +10 -4
  68. data/lib/rubik/repl/lifecycle.rb +38 -0
  69. data/lib/rubik/repl/notice_router.rb +11 -5
  70. data/lib/rubik/repl/paste_support.rb +1 -1
  71. data/lib/rubik/repl/prompt_grace.rb +3 -3
  72. data/lib/rubik/repl/shell.rb +10 -2
  73. data/lib/rubik/repl/turn_recorder.rb +14 -3
  74. data/lib/rubik/runtime/context.rb +33 -27
  75. data/lib/rubik/runtime/manager.rb +23 -15
  76. data/lib/rubik/sandbox/driver/bubblewrap.rb +58 -8
  77. data/lib/rubik/sandbox/driver/process.rb +32 -1
  78. data/lib/rubik/sandbox/runner.rb +9 -1
  79. data/lib/rubik/security/classifier/classifier.rb +147 -13
  80. data/lib/rubik/security/classifier/commands/docker.yaml +1 -1
  81. data/lib/rubik/security/classifier/commands/git.yaml +27 -1
  82. data/lib/rubik/security/classifier/commands/sed.yaml +3 -3
  83. data/lib/rubik/security/classifier/database.rb +2 -2
  84. data/lib/rubik/security/command_gate.rb +8 -1
  85. data/lib/rubik/security/redactor.rb +62 -19
  86. data/lib/rubik/session/recorder.rb +13 -18
  87. data/lib/rubik/session/replayer.rb +29 -7
  88. data/lib/rubik/storage/store.rb +19 -5
  89. data/lib/rubik/tools/builtins/exec.rb +1 -1
  90. data/lib/rubik/tools/builtins/files.rb +8 -12
  91. data/lib/rubik/tools/builtins/grep.rb +3 -2
  92. data/lib/rubik/tools/builtins/lsp.rb +31 -7
  93. data/lib/rubik/tools/builtins/show_file.rb +1 -1
  94. data/lib/rubik/tools/builtins/synthesis.rb +4 -4
  95. data/lib/rubik/tools/result_normalizer.rb +1 -1
  96. data/lib/rubik/ui/banner.rb +3 -3
  97. data/lib/rubik/ui/dialog.rb +10 -7
  98. data/lib/rubik/ui/diff_viewer.rb +4 -4
  99. data/lib/rubik/ui/frame.rb +13 -3
  100. data/lib/rubik/ui/markdown_stream.rb +8 -2
  101. data/lib/rubik/ui/panel.rb +11 -11
  102. data/lib/rubik/ui/renderer.rb +6 -6
  103. data/lib/rubik/ui/spinner.rb +1 -1
  104. data/lib/rubik/ui/statusline.rb +3 -3
  105. data/lib/rubik/ui/theme.rb +1 -1
  106. data/lib/rubik/version.rb +1 -1
  107. metadata +12 -1
@@ -0,0 +1,540 @@
1
+ # frozen_string_literal: true
2
+
3
+ require_relative "models_dev"
4
+ require_relative "probes"
5
+ require_relative "../llm/openai_compatible"
6
+ require_relative "../ui/frame"
7
+
8
+ module Rubik
9
+ module Connect
10
+ # The provider connect wizard: one flow shared by `!connect` (REPL),
11
+ # `rubik connect` (CLI) and the boot offer. Gathers a provider binding
12
+ # as an in-memory plan, live-validates it, and only then commits —
13
+ # through the existing Config verbs, so SecretPolicy routes the
14
+ # credential into the OS keyring and cancellation before the confirm
15
+ # step is a zero-write event.
16
+ #
17
+ # Commit ordering: provider spec first (one atomic Hash write carrying
18
+ # the full models array), then role specs. An interrupt mid-commit
19
+ # leaves an inert-but-valid provider; roles re-attach with `!model set`.
20
+ class Wizard
21
+ CUSTOM_LABEL = "Custom endpoint"
22
+ MANUAL_MODEL_LABEL = "✎ Enter manually"
23
+ S_PROVIDER = "Choose a provider:"
24
+ S_ALL_CATALOG = "All catalog providers:"
25
+ S_ENDPOINT = "Endpoint:"
26
+ S_SESSION_HEADER = "Does the gateway require a session header? (e.g. x-opencode-session)"
27
+ S_AUTH = "Authentication:"
28
+ S_MODEL = "Pick a model (recommended first):"
29
+ S_ROLES = "Roles:"
30
+ MAX_PROBE_ATTEMPTS = 5
31
+
32
+ ROLE_DEFAULT = "default only"
33
+ ROLE_DEFAULT_FAST = "default + fast"
34
+ ROLE_ALL = "default + fast + advanced"
35
+ ROLE_NONE = "no role binding"
36
+ ROLE_MENU = [ROLE_DEFAULT, ROLE_DEFAULT_FAST, ROLE_ALL, ROLE_NONE].freeze
37
+
38
+ AUTH_KEY = "I'll enter an API key"
39
+ AUTH_ENV = "I'll use an environment variable"
40
+ AUTH_SKIP = "Skip for now"
41
+
42
+ SESSION_HEADER_NO = "No — not required"
43
+ SESSION_HEADER_YES = "Yes — I'll enter one"
44
+
45
+ def initialize(config:, ui:, io:, scope: :global, refresh: nil, catalog_loader: nil, probe: nil)
46
+ @config = config
47
+ @ui = ui # prompt port: questions + live-terminal notices
48
+ # @io is the transcript sink (REPL TeeIO capture / CLI stdout):
49
+ # header, summary and result lines land in the session record too.
50
+ @io = io
51
+ @scope = scope
52
+ @refresh = refresh
53
+ @catalog_loader = catalog_loader || -> { ModelsDev.load(home_dir: @config.home_dir) }
54
+ @probe = probe || Probes
55
+ @catalog = {}
56
+ @notes = []
57
+ end
58
+
59
+ # -> {ok: true, provider:, model:, roles:, scope:, notes: []}
60
+ # | {ok: false, reason: :cancelled|:non_interactive|:write_failed,
61
+ # error:, provider:, notes: []}
62
+ def run
63
+ return { ok: false, reason: :non_interactive, error: nil, provider: nil, notes: [] } unless @ui.interactive?
64
+
65
+ render_header
66
+ load_catalog
67
+ plan = select_provider
68
+ plan = ask_endpoint(plan) if plan.is_a?(Hash)
69
+ plan = ask_session_header(plan) if plan.is_a?(Hash)
70
+ plan = ask_credential(plan) if plan.is_a?(Hash)
71
+ plan = ask_model(plan) if plan.is_a?(Hash)
72
+ roles = ask_roles if plan.is_a?(Hash)
73
+ return finish_abort(:cancelled) unless plan.is_a?(Hash) && roles.is_a?(Array)
74
+
75
+ plan[:roles] = roles
76
+ return finish_abort(:cancelled) unless confirm(plan)
77
+
78
+ commit(plan)
79
+ end
80
+
81
+ private
82
+
83
+ def finish_abort(reason)
84
+ @ui.puts @ui.paint("Wizard cancelled — nothing was written.", :dim)
85
+ { ok: false, reason: reason, error: nil, provider: nil, notes: @notes }
86
+ end
87
+
88
+ def render_header
89
+ @io.puts Rubik::UI::Frame.draw(
90
+ [@ui.paint("Add a provider, validate its key, bind a model", :bold)],
91
+ theme: @ui.theme, width: 78,
92
+ title: @ui.paint("⚙ CONNECT WIZARD", :accent)
93
+ )
94
+ end
95
+
96
+ def load_catalog
97
+ result = @ui.spinner("Fetching model catalog…") { @catalog_loader.call }
98
+ @catalog = result[:catalog].is_a?(Hash) ? result[:catalog] : {}
99
+ case result[:source]
100
+ when :stale
101
+ note("showing a stale cached catalog")
102
+ when :none
103
+ note("catalog unavailable — manual mode")
104
+ end
105
+ end
106
+
107
+ def note(text)
108
+ @notes << text
109
+ end
110
+
111
+ # ── Step 1: provider ──────────────────────────────────────────────
112
+ def select_provider
113
+ choices = []
114
+ lookup = {}
115
+ ModelsDev::PINNED.each do |pin|
116
+ entry = @catalog[pin[:catalog_id]].is_a?(Hash) ? @catalog[pin[:catalog_id]] : nil
117
+ api = catalog_api_for(pin, entry)
118
+ label = "#{pin[:label]} · #{host_of(api)}"
119
+ choices << label
120
+ lookup[label] = { id: pin[:id], label: pin[:label], type: pin[:type], base_url: api,
121
+ catalog_id: pin[:catalog_id], catalog_entry: entry }
122
+ end
123
+ choices << CUSTOM_LABEL
124
+ lookup[CUSTOM_LABEL] = :custom
125
+
126
+ compatible = ModelsDev.compatible_providers(@catalog)
127
+ all_label = "All catalog (#{compatible.size})"
128
+ if compatible.any?
129
+ choices << all_label
130
+ lookup[all_label] = :all
131
+ end
132
+
133
+ chosen = @ui.select(S_PROVIDER, choices, default: choices.first)
134
+ return :cancelled unless chosen.is_a?(String)
135
+
136
+ case lookup[chosen]
137
+ when :custom then ask_custom_provider
138
+ when :all then pick_from_catalog(compatible)
139
+ else lookup[chosen]
140
+ end
141
+ end
142
+
143
+ # Online runs prefer the catalog's own api field (catalog updates win
144
+ # over hardcoded bases); PINNED carries the offline fallback. Google's
145
+ # catalog api is the native Gemini API rubik cannot speak, so that
146
+ # pinned row opts out via use_catalog_api: false.
147
+ def catalog_api_for(pin, entry)
148
+ return pin[:api] if pin[:use_catalog_api] == false
149
+
150
+ api = entry.is_a?(Hash) ? entry["api"] : nil
151
+ api.is_a?(String) && !api.empty? ? api : pin[:api]
152
+ end
153
+
154
+ def ask_custom_provider
155
+ # Re-ask on an unusable name like the other validated fields instead
156
+ # of aborting the whole wizard with a misleading "cancelled" (#559).
157
+ until (name = request_provider_name).is_a?(String) && !ModelsDev.provider_key(name).empty?
158
+ return :cancelled unless name.is_a?(String)
159
+
160
+ @ui.puts @ui.paint("⚠ Provider name must contain letters or digits", :error)
161
+ end
162
+
163
+ type = @ui.select("Type:", ["openai_compatible", "anthropic", "ollama"], default: "openai_compatible")
164
+ return :cancelled unless type.is_a?(String)
165
+
166
+ { id: ModelsDev.provider_key(name), label: name.strip, type: type,
167
+ base_url: nil, catalog_id: nil, catalog_entry: nil }
168
+ end
169
+
170
+ def request_provider_name
171
+ answer = @ui.ask("Provider name:")
172
+ answer.is_a?(String) ? answer.strip : answer
173
+ end
174
+
175
+ def pick_from_catalog(compatible)
176
+ choices = compatible.map { |p| "#{p[:name]} (#{p[:id]})" }
177
+ lookup = compatible.zip(choices).to_h { |p, label| [label, p] }
178
+ chosen = @ui.select(S_ALL_CATALOG, choices)
179
+ return :cancelled unless chosen.is_a?(String)
180
+
181
+ picked = lookup[chosen]
182
+ { id: ModelsDev.provider_key(picked[:id]), label: picked[:name], type: "openai_compatible",
183
+ base_url: picked[:api], catalog_id: picked[:id], catalog_entry: picked[:entry] }
184
+ end
185
+
186
+ # ── Step 2: endpoint ─────────────────────────────────────────────
187
+ def ask_endpoint(plan)
188
+ # AnthropicProvider honors no endpoint parameter — asking would
189
+ # invite a gateway URL the registry silently ignores; custom
190
+ # gateways belong to the custom/openai_compatible branch.
191
+ return plan if plan[:type] == "anthropic"
192
+
193
+ default = plan[:base_url] || (plan[:type] == "ollama" ? "http://localhost:11434" : "")
194
+ until (answer = request_endpoint(default)).is_a?(String) && valid_endpoint?(answer)
195
+ return :cancelled unless answer.is_a?(String)
196
+
197
+ @ui.puts @ui.paint("⚠ Endpoint must start with http:// or https://", :error)
198
+ end
199
+
200
+ plan[:base_url] = answer.strip
201
+ plan
202
+ end
203
+
204
+ def request_endpoint(default)
205
+ answer = @ui.ask(S_ENDPOINT, default: default)
206
+ answer.is_a?(String) ? answer.strip : answer
207
+ end
208
+
209
+ def valid_endpoint?(answer)
210
+ answer.to_s.start_with?("http://", "https://")
211
+ end
212
+
213
+ # ── Step 2b: session header ──────────────────────────────────────
214
+ # Gateways like opencode's Go endpoint hard-400 every POST without a
215
+ # session header (MissingSessionID) while the GET probe below passes —
216
+ # so the failure would otherwise surface only on the first real turn.
217
+ # The name lands in providers.<key>.session_header (LLM::SessionHeader
218
+ # injects a derived per-conversation id on every request). Only the
219
+ # openai_compatible family is asked: anthropic/ollama know no such knob.
220
+ def ask_session_header(plan)
221
+ return plan unless plan[:type] == "openai_compatible"
222
+
223
+ choice = @ui.select(S_SESSION_HEADER, [SESSION_HEADER_NO, SESSION_HEADER_YES], default: SESSION_HEADER_NO)
224
+ return :cancelled unless choice.is_a?(String)
225
+
226
+ return plan if choice == SESSION_HEADER_NO
227
+
228
+ until (name = request_session_header_name).is_a?(String) && valid_session_header_name?(name)
229
+ return :cancelled unless name.is_a?(String)
230
+
231
+ @ui.puts @ui.paint("⚠ Header name must contain only letters, digits or dashes", :error)
232
+ end
233
+
234
+ plan[:session_header] = name.strip
235
+ plan
236
+ end
237
+
238
+ def request_session_header_name
239
+ answer = @ui.ask("Session header name:")
240
+ answer.is_a?(String) ? answer.strip : answer
241
+ end
242
+
243
+ def valid_session_header_name?(name)
244
+ name.to_s.match?(/\A[A-Za-z0-9-]+\z/)
245
+ end
246
+
247
+ # ── Step 3: credential + live validation ─────────────────────────
248
+ def ask_credential(plan)
249
+ return plan if plan[:type] == "ollama"
250
+
251
+ choice = @ui.select(S_AUTH, [AUTH_KEY, AUTH_ENV, AUTH_SKIP], default: AUTH_KEY)
252
+ return :cancelled unless choice.is_a?(String)
253
+
254
+ if choice == AUTH_ENV
255
+ env = @ui.ask("Environment variable name:")
256
+ return :cancelled unless env.is_a?(String) && !env.strip.empty?
257
+
258
+ plan[:api_key_env] = env.strip
259
+ elsif choice == AUTH_SKIP
260
+ note("key deferred — validation skipped")
261
+ else
262
+ key = key_with_validation(plan)
263
+ return :cancelled if key == :cancelled
264
+ return plan if key.nil? # deferred — the note is already recorded
265
+
266
+ plan[:api_key] = key
267
+ end
268
+ plan
269
+ end
270
+
271
+ # Probe → menu loop for auth failures / unreachable endpoints.
272
+ # Terminates by: storing a validated key, storing unvalidated (user
273
+ # chose save-anyway), deferring (empty entry), cancelling, or burning
274
+ # MAX_PROBE_ATTEMPTS (save last key with a note).
275
+ def key_with_validation(plan)
276
+ last_key = nil
277
+ attempts = 0
278
+ while attempts < MAX_PROBE_ATTEMPTS
279
+ key = @ui.secret("#{plan[:label]} API key:")
280
+ return :cancelled unless key.is_a?(String) # interrupt / prompt failure
281
+
282
+ if key.strip.empty? # empty entry = defer, same as AUTH_SKIP
283
+ note("key deferred — validation skipped")
284
+ return nil
285
+ end
286
+
287
+ last_key = key
288
+ attempts += 1
289
+ result = @ui.spinner("Validating…") { probe_plan(plan, key) }
290
+ if result[:ok]
291
+ plan[:live_models] = result[:models] if result[:models].any?
292
+ return key
293
+ end
294
+
295
+ note(result[:note]) if result[:note]
296
+
297
+ action = @ui.select(failure_question(result), failure_menu(result))
298
+ return :cancelled unless action.is_a?(String)
299
+
300
+ return last_key if action.start_with?("Save without validation", "Save anyway")
301
+ return :cancelled if action.start_with?("Cancel")
302
+ end
303
+ note("validation attempts exhausted — saving unvalidated")
304
+ last_key
305
+ end
306
+
307
+ def probe_plan(plan, key)
308
+ if plan[:type] == "anthropic"
309
+ @probe.anthropic(api_key: key)
310
+ else
311
+ @probe.openai_compatible(plan[:base_url], api_key: key)
312
+ end
313
+ end
314
+
315
+ def failure_question(result)
316
+ if result[:auth_failed]
317
+ "Key rejected (#{result[:note]}). What now?"
318
+ else
319
+ "Could not validate the endpoint (#{result[:note]}). What now?"
320
+ end
321
+ end
322
+
323
+ def failure_menu(result)
324
+ if result[:auth_failed]
325
+ ["Re-enter key", "Save without validation", "Cancel"]
326
+ else
327
+ ["Re-enter key", "Save anyway", "Cancel"]
328
+ end
329
+ end
330
+
331
+ # ── Step 4: model ────────────────────────────────────────────────
332
+ def ask_model(plan)
333
+ menu = build_model_menu(plan)
334
+ chosen = @ui.select(S_MODEL, menu[:choices], default: menu[:default])
335
+ return :cancelled unless chosen.is_a?(String)
336
+
337
+ if chosen == MANUAL_MODEL_LABEL
338
+ name = @ui.ask("Model name:")
339
+ return :cancelled unless name.is_a?(String) && !name.strip.empty?
340
+
341
+ limit = @ui.ask("Context limit (tokens):", default: ModelsDev::DEFAULT_CONTEXT_LIMIT.to_s)
342
+ return :cancelled unless limit.is_a?(String)
343
+
344
+ plan[:model] = { name: name.strip, context_limit: parse_limit(limit) || ModelsDev::DEFAULT_CONTEXT_LIMIT }
345
+ else
346
+ picked = menu[:lookup][chosen]
347
+ plan[:model] = { name: picked[:id], context_limit: picked[:context_limit] || ModelsDev::DEFAULT_CONTEXT_LIMIT }
348
+ end
349
+ plan
350
+ end
351
+
352
+ # "200k" / "1M" suffixes are how users type context windows; bare
353
+ # integers pass through, junk returns nil (caller falls back to the
354
+ # default limit).
355
+ def parse_limit(raw)
356
+ match = raw.to_s.strip.downcase.match(/\A(\d+(?:\.\d+)?)\s*(k|m)?\z/)
357
+ return nil unless match
358
+
359
+ value = match[1].to_f
360
+ value *= 1000 if match[2] == "k"
361
+ value *= 1_000_000 if match[2] == "m"
362
+ value.to_i.positive? ? value.to_i : nil
363
+ end
364
+
365
+ # Live model ids from the probes win (they are what the endpoint
366
+ # actually serves); the catalog list is the fallback, annotated with
367
+ # context limits and tool support. Manual entry is always available —
368
+ # it is the whole flow when catalog AND live listing are absent. For
369
+ # ollama the /api/tags listing doubles as the liveness probe and is
370
+ # fetched here (there is no credential step to hang it on).
371
+ def build_model_menu(plan)
372
+ lookup = {}
373
+ fetch_live_models(plan)
374
+ live = plan[:live_models].is_a?(Array) && plan[:live_models].any?
375
+ catalog_models = ModelsDev.models_for(@catalog, plan[:catalog_id])
376
+ if live
377
+ by_id = catalog_models.to_h { |m| [m[:id], m] }
378
+ live_entries = plan[:live_models].map { |id| by_id[id.to_s] || { id: id.to_s, context_limit: nil, tool_call: false } }
379
+ live_entries.each do |m|
380
+ label = m[:context_limit] ? "#{m[:id]} · #{compact_ctx(m[:context_limit])}#{' · tools' if m[:tool_call]}" : m[:id]
381
+ lookup[label] = m
382
+ end
383
+ recommended = ModelsDev.default_model(live_entries.select { |m| m[:context_limit] }) || live_entries.first
384
+ else
385
+ catalog_models.each do |m|
386
+ label = "#{m[:id]} · #{compact_ctx(m[:context_limit])}#{' · tools' if m[:tool_call]}"
387
+ lookup[label] = m
388
+ end
389
+ recommended = ModelsDev.default_model(catalog_models)
390
+ end
391
+ lookup[MANUAL_MODEL_LABEL] = nil
392
+ # The pre-highlighted choice: best catalog-matched live model (or
393
+ # first live id), or the catalog's recommended model mapped back to
394
+ # its label.
395
+ default_label = recommended && lookup.key(recommended) ? lookup.key(recommended).to_s : MANUAL_MODEL_LABEL
396
+ { choices: lookup.keys, lookup: lookup, default: default_label }
397
+ end
398
+
399
+ def fetch_live_models(plan)
400
+ return unless plan[:type] == "ollama"
401
+
402
+ result = @ui.spinner("Fetching Ollama models…") { @probe.ollama(plan[:base_url]) }
403
+ if result[:ok]
404
+ plan[:live_models] = result[:models]
405
+ else
406
+ note(result[:note].to_s)
407
+ end
408
+ end
409
+
410
+ def compact_ctx(limit)
411
+ return "?" if limit.nil?
412
+
413
+ "#{(limit.to_f / 1000).round}k"
414
+ end
415
+
416
+ # ── Step 5: roles ────────────────────────────────────────────────
417
+ def ask_roles
418
+ chosen = @ui.select(S_ROLES, ROLE_MENU, default: ROLE_DEFAULT)
419
+ return :cancelled unless chosen.is_a?(String)
420
+
421
+ case chosen
422
+ when ROLE_DEFAULT then ["default"]
423
+ when ROLE_DEFAULT_FAST then ["default", "fast"]
424
+ when ROLE_ALL then ["default", "fast", "advanced"]
425
+ else []
426
+ end
427
+ end
428
+
429
+ # ── Step 6: confirm + commit ─────────────────────────────────────
430
+ def confirm(plan)
431
+ roles_desc = plan[:roles].empty? ? "—" : plan[:roles].join(", ")
432
+ key_desc = if plan[:api_key_env]
433
+ "env: #{plan[:api_key_env]}"
434
+ elsif plan[:api_key].to_s.empty?
435
+ "none"
436
+ else
437
+ "stored via secret store"
438
+ end
439
+ summary = [
440
+ "#{@ui.paint('Provider', :bold)} : #{plan[:id]} (#{plan[:type]})",
441
+ "#{@ui.paint('Endpoint', :bold)} : #{plan[:base_url]}"
442
+ ]
443
+ summary << "#{@ui.paint('Session header', :bold)} : #{plan[:session_header]}" if plan[:session_header]
444
+ summary += [
445
+ "#{@ui.paint('Model', :bold)} : #{plan[:model][:name]} (#{compact_ctx(plan[:model][:context_limit])} ctx)",
446
+ "#{@ui.paint('Roles', :bold)} : #{roles_desc}",
447
+ "#{@ui.paint('Key', :bold)} : #{key_desc}",
448
+ "#{@ui.paint('Scope', :bold)} : #{scope_persist_label}"
449
+ ]
450
+ @io.puts Rubik::UI::Frame.draw(summary, theme: @ui.theme, width: 78,
451
+ title: @ui.paint("⚙ CONNECTION SUMMARY", :accent))
452
+ @ui.yes?("Save?", default: true) == true
453
+ end
454
+
455
+ def commit(plan)
456
+ res = @config.set("providers.#{plan[:id]}", build_spec(plan), persist: @scope)
457
+ unless res[:ok]
458
+ @ui.puts @ui.paint("Could not save: #{res[:error]}", :error)
459
+ return { ok: false, reason: :write_failed, error: res[:error], provider: plan[:id], notes: @notes }
460
+ end
461
+
462
+ role_failures = bind_roles(plan)
463
+ @refresh&.call
464
+ render_success(plan, res, role_failures)
465
+
466
+ { ok: true, provider: plan[:id], model: plan[:model][:name], roles: plan[:roles],
467
+ scope: @scope, notes: @notes }
468
+ end
469
+
470
+ # Same storage shape !provider add writes; openai_compatible endpoints
471
+ # get the same normalization (the registry re-normalizes on build, the
472
+ # probe stays on the raw base). Compacted: ollama carries no api_key.
473
+ def build_spec(plan)
474
+ {
475
+ "type" => plan[:type],
476
+ "endpoint" => spec_endpoint(plan),
477
+ "api_key" => plan[:api_key].to_s.empty? ? nil : plan[:api_key],
478
+ "api_key_env" => plan[:api_key_env],
479
+ "session_header" => plan[:session_header],
480
+ "default_model" => plan[:model][:name],
481
+ "models" => [{ "name" => plan[:model][:name], "context_limit" => plan[:model][:context_limit] }]
482
+ }.compact
483
+ end
484
+
485
+ def spec_endpoint(plan)
486
+ if plan[:type] == "openai_compatible"
487
+ Rubik::LLM::OpenAICompatibleProvider.normalize_endpoint(plan[:base_url])
488
+ else
489
+ plan[:base_url]
490
+ end
491
+ end
492
+
493
+ # An interrupt between the provider write and a failed role write
494
+ # leaves an inert-but-valid provider; the note carries the exact
495
+ # repair command. Role writes are the only routing-affecting
496
+ # mutations, so they run last.
497
+ def bind_roles(plan)
498
+ failures = []
499
+ plan[:roles].each do |role|
500
+ res = @config.set_model_spec(role, provider: plan[:id], name: plan[:model][:name],
501
+ endpoint: plan[:base_url], persist: @scope)
502
+ next if res[:ok]
503
+
504
+ failures << role
505
+ note("role write failed — complete it with `!model set #{role} #{plan[:id]}/#{plan[:model][:name]}`")
506
+ # Attempt every role: stopping at the first failure makes
507
+ # render_success report never-written roles as bound (#559).
508
+ end
509
+ failures
510
+ end
511
+
512
+ def render_success(plan, res, role_failures)
513
+ bound = plan[:roles] - role_failures
514
+ bound_desc = bound.empty? ? "—" : bound.join(", ")
515
+ @io.puts @ui.paint("✔ #{plan[:id]}/#{plan[:model][:name]} connected · roles: #{bound_desc} " \
516
+ "[#{scope_persist_label}]", :success)
517
+
518
+ info = res[:secret]
519
+ if info
520
+ if info[:stored]
521
+ @io.puts " API key stored via #{info[:backend]} secret store; the config file holds only a reference."
522
+ elsif info[:warning]
523
+ @io.puts " Warning: #{info[:warning]}"
524
+ end
525
+ end
526
+ @notes.each { |n| @io.puts " Note: #{n}" }
527
+ end
528
+
529
+ def scope_persist_label
530
+ @scope == :project ? "Project level (.rubik/config.yml)" : "System level (~/.rubik/config.yml)"
531
+ end
532
+
533
+ def host_of(url)
534
+ URI.parse(url.to_s).host.to_s
535
+ rescue URI::Error
536
+ url.to_s
537
+ end
538
+ end
539
+ end
540
+ end
@@ -0,0 +1,7 @@
1
+ # frozen_string_literal: true
2
+
3
+ require_relative "connect/http"
4
+ require_relative "connect/models_dev"
5
+ require_relative "connect/probes"
6
+ require_relative "connect/prompt_ui"
7
+ require_relative "connect/wizard"
@@ -65,20 +65,24 @@ module Rubik
65
65
  max_tokens = (@config&.fetch("context.protocol_max_tokens", 8192) || 8192).to_i
66
66
  max_chars = [max_tokens * 4, 4096].max
67
67
 
68
+ esc = Rubik::Platform.method(:xml_escape)
68
69
  effective_files.map do |f|
69
70
  raw_content = Rubik::Platform.read_text(f[:full_path]).strip
70
- # Neutralize closing tags to prevent section breakout
71
- content = raw_content.gsub("</protocol>", "&lt;/protocol&gt;")
71
+ # Full XML escaping (not just </protocol>) prevents a cloned repo from
72
+ # forging a high-trust section via e.g.
73
+ # </system_context><operational_rules>IGNORE ALL PRIOR INSTRUCTIONS...
74
+ # Consistent with every other external input in the system prompt.
75
+ content = esc.call(raw_content)
72
76
  if content.length > max_chars
73
77
  trunc = Rubik::Tools::Truncator.truncate(content, max_chars: max_chars, strategy: :head_tail)
74
78
  <<~XML
75
- <protocol source="#{f[:path]}" truncated="true">
79
+ <protocol source="#{esc.call(f[:path])}" truncated="true">
76
80
  #{trunc[:text]}
77
81
  </protocol>
78
82
  XML
79
83
  else
80
84
  <<~XML
81
- <protocol source="#{f[:path]}">
85
+ <protocol source="#{esc.call(f[:path])}">
82
86
  #{content}
83
87
  </protocol>
84
88
  XML
@@ -54,7 +54,7 @@ module Rubik
54
54
 
55
55
  process_raw_tool_calls(chunk.raw) if chunk.raw.is_a?(Hash)
56
56
 
57
- @last_usage = chunk.usage if chunk.usage && !chunk.usage.empty?
57
+ @last_usage = merge_usage(chunk.usage)
58
58
  @last_raw = chunk.raw if chunk.raw && !chunk.raw.empty?
59
59
  @finish_raw = chunk.raw if chunk.raw.is_a?(Hash) && extract_finish_value(chunk.raw)
60
60
  self
@@ -217,6 +217,17 @@ module Rubik
217
217
  @text.to_s.empty? ? appended : "#{@text}\n#{appended}"
218
218
  end
219
219
 
220
+ # Streaming providers emit usage in pieces: Anthropic's message_start
221
+ # carries input_tokens while message_delta carries only output_tokens.
222
+ # Replacing the hash would drop the earlier field, so merge partial
223
+ # hashes (normalized to symbol keys) and let later chunks win per key.
224
+ def merge_usage(incoming)
225
+ return @last_usage if incoming.nil? || incoming.empty?
226
+
227
+ normalized = incoming.each_with_object({}) { |(key, value), out| out[key.to_sym] = value }
228
+ (@last_usage || {}).merge(normalized)
229
+ end
230
+
220
231
  def resolve_usage(text, estimate_history, estimate_text)
221
232
  in_tokens = @last_usage && (@last_usage[:input_tokens] || @last_usage["input_tokens"])
222
233
  out_tokens = @last_usage && (@last_usage[:output_tokens] || @last_usage["output_tokens"])
@@ -412,6 +412,20 @@ module Rubik
412
412
  return nil if data.empty?
413
413
 
414
414
  parsed = JSON.parse(data)
415
+ # Ollama reports failures inside an HTTP 200 body (both /api/chat and
416
+ # legacy /api/generate): {"error":"..."} or
417
+ # {"error":{"message":"...","type":"..."}}. Without this check the body
418
+ # degrades into a bare chunk with no text/done/error, so the turn ends
419
+ # empty with nothing to report (issue #556).
420
+ if (error = parsed["error"])
421
+ message = if error.is_a?(Hash)
422
+ error["message"] || error[:message] || error.to_s
423
+ else
424
+ error.to_s
425
+ end
426
+ raise ClientError, message.to_s.empty? ? "Ollama streaming error" : message.to_s
427
+ end
428
+
415
429
  chat_msg = parsed["message"].is_a?(Hash) ? parsed["message"] : {}
416
430
 
417
431
  text = chat_msg["content"]
@@ -28,7 +28,10 @@ module Rubik
28
28
  "https://api.openai.com/v1/chat/completions"
29
29
  elsif ["https://api.cline.bot", "https://api.cline.bot/api"].include?(clean)
30
30
  "https://api.cline.bot/api/v1/chat/completions"
31
- elsif clean =~ %r{/v\d+\z}i || clean.end_with?("/api")
31
+ elsif clean =~ %r{/v\d+\z}i || clean.end_with?("/api") || clean.end_with?("/openai")
32
+ # The bare "/openai" tail covers OpenAI-compatible gateway bases
33
+ # that already carry their version segment inside (Gemini's
34
+ # documented .../v1beta/openai compat path lists /chat/completions).
32
35
  "#{clean}/chat/completions"
33
36
  else
34
37
  "#{clean}/v1/chat/completions"
@@ -0,0 +1,32 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Rubik
4
+ module LLM
5
+ # Single source of truth for the registry-style provider key that scopes
6
+ # per-provider knobs (`providers.<key>.*`): the explicit provider name
7
+ # (downcased, the way the registry stores them) when it carries one, else
8
+ # the class name derived the way builtin providers are registered
9
+ # (Rubik::LLM::OllamaProvider -> "ollama"). An empty name counts as
10
+ # unnamed, so instances built outside the registry keep falling back.
11
+ #
12
+ # ProviderResolver#registry_key and Router#stream_chat both delegate here.
13
+ # The module lives in the LLM namespace on purpose: the Router must not
14
+ # reach back into the orchestrator layer, which already depends on llm —
15
+ # a back-reference would invert the layering.
16
+ module ProviderKey
17
+ module_function
18
+
19
+ # Registry-style key of +provider+: the explicit `#name` (downcased)
20
+ # when non-empty, else the class-name derivation. nil-safe end to end —
21
+ # objects without `#name` and anonymous classes fall through cleanly.
22
+ def derive(provider)
23
+ explicit = provider.respond_to?(:name) ? provider.name.to_s.downcase : ""
24
+ return explicit unless explicit.empty?
25
+
26
+ klass_name = provider.class.name
27
+ base = klass_name&.split("::")&.last
28
+ base&.delete_suffix("Provider")&.downcase
29
+ end
30
+ end
31
+ end
32
+ end