planka-cli 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dabd1d040fd4dede722ec5c62b8e60d37f2a344b80e825862c8dd7c9843c0d79
-  data.tar.gz: 7a900110053223770ce56dda103e5b47c99809b98ba682618d1c1dcb042cbb39
+  metadata.gz: b2ddf9bdb8529ed70987d7c273f935aab7c045a5dd3f6a5215ed7ffcd252da63
+  data.tar.gz: d4a59fb87d01349a42d6e229e64d204d47dd0573bd54a3bc64bf6e0b98c8d0ff
 SHA512:
-  metadata.gz: a2042e943919152542795ddc968803f7274c17bb3e114d40b55b774ed7c7e6d024befffce847bf17cf8867b524b25d1764cae049240ecf2d9b8f7be15c6e923b
-  data.tar.gz: f8491ffec2927b09ebda03abfe934e8eafdac147ca8ddf41497c8b3b7360976079cd401b0bf257b0d068d43fc9f5c07e9a7d38f338ccd8f486d1af112c986ad1
+  metadata.gz: b85b944f8308805e48a5756a649a02f379dbde6d6130d0548b758afa09d7494e08708e0b6439c1fc08640825edd81cd83ece4deb68db1ac9ec44d7ff276c3768
+  data.tar.gz: 3ed86441e6e7bee6aeab7df92b3955e7d96cd61d545a530031559f3e5a4b63a22d2d6ff125f69863591634bca77700af9e0365b8800973f9e5acc58a929c4800

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+Extracted Planka Ruby workflows from Lucenta; added configurable instance, board and branch prefix, gem packaging, and the `planka` command.

data/README.md

@@ -1,161 +1,86 @@
 # planka-cli
 
-Ruby command-line tools and workflow utilities for Planka's REST API. Extracted
-from Lucenta into this standalone local repository; no remote has been created
-and the gem has not been published. `work-next` and `pr_assets` remain in Lucenta.
+Ruby CLI and library for Planka board workflows, extracted from Lucenta.
+Requires Ruby 3.2 or newer. Board workflows use the conventions
+`ready-for-agent`, `in-progress`, `done`, `Acceptance criteria`, `Blocked by`,
+`feature:<slug>` and `effort:<slug>`. Linked tasks represent blocking edges.
 
-## Install
-
-Use Ruby 3.4 or newer (development uses 3.4.9), Bundler, and Bash. From this
-repository:
+## Install locally
 
 ```sh
 bundle install
-gem build planka-cli.gemspec
-gem install ./planka-cli-0.1.0.gem
+make ci
+gem install ./pkg/planka-cli-0.1.0.gem
+planka --help
 ```
 
-Put RubyGems' executable directory on `PATH`. Invoke `planka-*` commands from
-the checkout whose configuration you want to use, not from this gem's directory.
-Ruby launchers package the shell implementations of `planka-op` and `planka-mcp`
-so the commands also work through RubyGems' installed executable wrappers.
-
-For the current sibling-directory extraction, Lucenta's Gemfile uses:
+The gem has not been published. Its executable names include `planka` and
+all eight existing `planka-*` commands. `bin/planka-op` and the Node MCP
+launcher remain in Lucenta; they are repository integrations rather than Ruby
+gem commands.
 
-```ruby
-source "https://rubygems.org"
-gem "planka-cli", path: "../planka-cli"
-```
+## Configure
 
-Run `bundle install` in Lucenta, then use `bundle exec planka-next-card` and the
-other installed commands. Relocating the checkout requires updating that path.
-After deciding on a remote and publishing the gem to RubyGems, replace the path
-with a released version constraint and update the bundle. No remote or
-publication is assumed by the current setup.
+Supply resolved credentials in the process environment:
 
-## Configuration
+| Variable | Used for |
+| --- | --- |
+| `PLANKA_BASE_URL` | Instance URL, e.g. `https://planka.example.com` |
+| `PLANKA_AGENT_EMAIL` | Login email or username |
+| `PLANKA_AGENT_PASSWORD` | Login password |
+| `PLANKA_BOARD_ID` | Board used by `next-card` only |
+| `PLANKA_BRANCH_PREFIX` | Optional preview/DNS prefix, e.g. `lucenta-`; default empty |
 
-The command's **current working directory** owns `.mcp.json` and `.env.op`.
-Nothing is loaded from the installed gem, Lucenta, or a homelab checkout.
+Card commands derive the board from the card. `loop-lock` and `spec-sweep`
+inspect all boards visible to the signed-in user. No command reads `.mcp.json`,
+looks in another checkout for secrets, or invokes 1Password automatically.
+For `op://` references, launch the command through your own `op run` setup.
 
-| Variable | Purpose |
-| --- | --- |
-| `PLANKA_BASE_URL` | Planka instance URL, for example `http://localhost:3000`. Also used to render card links. |
-| `PLANKA_AGENT_EMAIL` | User email or username for API sign-in. |
-| `PLANKA_AGENT_PASSWORD` | Password for API sign-in. |
-| `PLANKA_BOARD_ID` | Board selected by `planka-next-card` and `Planka.board_id`. No default board exists. |
-| `PLANKA_MCP_CONFIG` | Optional MCP config filename; relative paths resolve from the current working directory. Defaults to `.mcp.json` if present. An explicitly selected missing file is an error. |
-| `OP_SERVICE_ACCOUNT_TOKEN` | Exported 1Password service-account token; no env file is needed when already set. |
-| `OP_ENV_FILE` | Optional file to source when no token is exported; relative to the current working directory. Otherwise `.env.op` is used. |
-| `XDG_STATE_HOME` | Optional state root for 1Password's isolated home; defaults to `$HOME/.local/state`. |
-
-Explicit environment variables override values in the selected MCP config's
-`mcpServers.planka.env`. Plain credentials need neither an MCP config nor
-1Password:
+## Commands
 
 ```sh
-export PLANKA_BASE_URL=http://localhost:3000
-export PLANKA_AGENT_EMAIL=agent@example.test
-export PLANKA_AGENT_PASSWORD='your-password'
-export PLANKA_BOARD_ID='your-board-id'
-planka-next-card
+planka next-card                  # top unclaimed, unblocked ticket by position
+planka next-card feature:search   # earliest takeable ticket for a feature
+planka next-card effort:search    # wayfinder map and frontier
+planka branch-name CARD           # branch slug; fits 63 chars including prefix
+planka unticked CARD              # incomplete acceptance criteria
+planka loop-lock                  # signed-in user's open claim without PR handoff
+planka claim CARD                 # add membership and move to in-progress
+planka comment CARD 'Branch: card/example'
+planka link BLOCKED BLOCKER [BLOCKER...]
+planka spec-sweep                 # comment and move finished specs to done
 ```
 
-Alternatively, create a caller-owned MCP config (substitute your URL, board,
-and secret references):
-
-```json
-{
-  "mcpServers": {
-    "planka": {
-      "command": "planka-mcp",
-      "env": {
-        "PLANKA_BASE_URL": "http://localhost:3000",
-        "PLANKA_BOARD_ID": "your-board-id",
-        "PLANKA_AGENT_EMAIL": "op://vault/planka-agent/username",
-        "PLANKA_AGENT_PASSWORD": "op://vault/planka-agent/password"
-      }
-    }
-  }
-}
-```
+Cards may be numeric ids or card URLs. `claim`, `comment`, `link` and
+`spec-sweep` write to Planka. `claim` and `link` may be safely repeated.
+`next-card` uses the authenticated `gh` CLI when a blocker has a GitHub PR
+handoff. `Branch:` and `PR:` lines in comments determine parent branches.
 
-When `PLANKA_*` settings contain `op://` references, the command re-runs through
-its packaged `planka-op` wrapper. Install the 1Password `op` CLI and export a
-service-account token or create `.env.op` containing
-`OP_SERVICE_ACCOUNT_TOKEN='your-token'`. Treat the file as a shell file; it is
-sourced, not parsed as dotenv. Keep credential files out of version control.
-The wrapper isolates 1Password state under `planka-cli/op-home`, restores the
-real `HOME` for the child command, and uses `op run --no-masking` to preserve JSON
-and MCP streams. Do not print secret values from commands run through it.
+## Library
 
-`planka-mcp` uses Node.js/npm's `npx` to launch
-`@navyatec/planka-v2-mcp@1.3.4`. It applies the same config and credential rules;
-plain values do not invoke `op`. In an MCP client using the local path bundle,
-use `"command": "bundle", "args": ["exec", "planka-mcp"]` instead.
+```ruby
+require "planka-cli"
 
-## Commands
+Planka::Client.session do |client|
+  board = Planka::Board.new(client.board(ENV.fetch("PLANKA_BOARD_ID")),
+    base_url: ENV.fetch("PLANKA_BASE_URL"))
+  puts board.cards.first
+end
+```
 
-A `<card>` argument accepts a numeric ID or a card URL. Commands preserve their
-line-oriented workflow output; there is no implicit board or instance.
+`Board` also accepts a captured API `included` payload. Supply `base_url:` when
+using multiple instances in one process. `BranchName.for(card, prefix: "app-")`
+accepts a per-call prefix. The library preserves the `Planka` namespace.
 
-| Command | Behavior |
-| --- | --- |
-| `planka-next-card [feature-label\|effort-label]` | Read-only selection on `PLANKA_BOARD_ID`. With no label, chooses the first takeable ticket by list position. Feature selection uses creation order and reports spec, ticket number, blockers and parent branch. Effort selection reports a wayfinder map and frontier. |
-| `planka-branch-name <card>` | Prints the workflow branch name; read-only. |
-| `planka-claim <card>` | Adds the signed-in user as a member if needed and moves the card to its board's `in-progress` list. Safe to repeat. |
-| `planka-comment <card> <text>` | Adds a comment as the signed-in user. Quote multiline text as one argument. |
-| `planka-link <blocked-card> <blocker-card>...` | Adds linked blocking tasks in a `Blocked by` task list. Existing edges are skipped; self-blocking is rejected. |
-| `planka-unticked <card>` | Prints incomplete tasks in `Acceptance criteria`, one per line; read-only. |
-| `planka-loop-lock` | Searches all visible boards for an open claimed card without a PR handoff, printing `free` or `held`, claim time and age; read-only. |
-| `planka-spec-sweep` | Searches all visible boards, comments on completed feature specs in `in-progress`, and moves them to `done`. |
-| `planka-op <command> [args...]` | Resolves secret references in a command's environment using `op run`; requires a service-account token. |
-| `planka-mcp` | Starts the pinned Planka MCP server using `npx`. |
-
-The Ruby utilities are available with `require "planka"` and
-`require "planka/client"`. `Planka::Client.configure!` loads caller-owned MCP
-settings into unset environment variables; `resolve_credentials!(script, argv)`
-additionally validates API credentials and resolves secret references by
-re-executing the calling script. `Client.session` signs in and signs out around
-the supplied block. `Planka.board_id` fetches `PLANKA_BOARD_ID` and
-`Planka.card_url(id)` joins the configured base URL with `/cards/<id>`.
-
-## Workflow conventions and dependencies
-
-These tools retain the extracted workflow conventions rather than imposing a
-general-purpose Planka schema:
-
-- Tickets have an `Acceptance criteria` task list; specs do not. Selection
-  requires an unclaimed card in `ready-for-agent` with no incomplete linked
-  blocking tasks. Lists have Planka `active` or `closed` types.
-- Claiming uses `in-progress`; completed specs move to `done`.
-- `feature:<slug>` associates specs and tickets. `effort:<slug>` groups wayfinder
-  cards; `wayfinder:map` identifies their map.
-- Blocking edges are linked tasks. Planka completes those tasks when their
-  linked blocker cards close.
-- Handoff comments contain `Branch: <branch>` and optionally `PR: <url>` on
-  separate lines. PR inspection uses an authenticated GitHub `gh` CLI when a
-  handoff references a PR; run it in the relevant project checkout.
-- Branches are `feature/<feature>-<title-slug>` or `card/<title-slug>`. The
-  historical 55-character limit is preserved, reserving eight characters for
-  the Lucenta workflow's `lucenta-` DNS/Compose prefix. Names cut at whole words;
-  this extraction does not redesign that convention.
-
-Only secret-reference resolution requires `op`. MCP additionally needs `npx`
-and network access for its pinned package. API commands need network access to
-the configured Planka instance; PR-dependent selection needs `gh`.
-
-## Development
+## Development and extraction boundary
 
-```sh
-bundle install
-make test
-make ci
-```
+`make test` runs the captured-board tests and local HTTP command tests.
+`make build` builds the gem; `make ci` runs both. CI covers Ruby 3.2, 3.4 and 4.0.
+The tests do not contact a live Planka instance. API endpoints and payload shapes
+are inherited from Lucenta, including its captured Community board fixture;
+compatibility with other Planka releases has not been established.
 
-Both targets run the standalone Minitest suite. Moved fixtures retain their
-`test/fixtures/files/planka` layout. Tests and their helper are included in the
-gem so Lucenta's remaining workflow tests can share the extracted board fixture.
-Gem artifacts, Bundler state, coverage, and local credential/config files are
-ignored. This README records the standalone extraction and configuration
-cutover; the former hardcoded instance and board constants have been removed.
+Lucenta continues using its original library and 1Password integrations.
+Switching it to this gem is a separate consumer change once a repository or
+release is available to CI. No release license has been selected; choose one
+before publishing the gem.

data/exe/planka

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require "planka-cli"
+
+commands = %w[link next-card branch-name claim comment unticked spec-sweep loop-lock]
+if ARGV == ["--version"]
+  puts Planka::VERSION
+elsif ARGV.empty? || ARGV == ["--help"]
+  puts "usage: planka <command> [arguments]\ncommands: #{commands.join(', ')}"
+else
+  command = ARGV.shift
+  abort "planka: unknown command #{command.inspect}; see planka --help" unless commands.include?(command)
+  load File.expand_path("planka-#{command}", __dir__)
+end

data/{bin → exe}/planka-branch-name

@@ -2,17 +2,16 @@
 # Prints the branch a card is worked on, e.g.
 # feature/tracer-1.2-an-account-signs-in-the-first-admin. Read-only.
 #
-#   bin/planka-branch-name <card>     an id or card URL
+#   planka-branch-name <card>     an id or card URL
 #
 # The logic lives in lib/planka/branch_name.rb.
-require_relative "../lib/planka"
-require_relative "../lib/planka/client"
+require "planka"
+require "planka/client"
 
 abort "usage: planka-branch-name <card>" unless ARGV.size == 1
 
 begin
   card_id = Planka.card_id(ARGV.first)
-  Planka::Client.resolve_credentials!(__FILE__, ARGV)
 
   Planka::Client.session do |client|
     board = Planka::Board.new(client.board(client.card(card_id).dig("item", "boardId")))

data/{bin → exe}/planka-claim

@@ -2,18 +2,16 @@
 # Claims a card for the signed-in user: makes it a card member, then moves the
 # card to its board's in-progress list. Safe to re-run.
 #
-#   bin/planka-claim <card>     an id or card URL
+#   planka-claim <card>     an id or card URL
 #
-# The work-next loop runs it as its own user
-# (PLANKA_MCP_CONFIG=workflows/work-next/mcp.json).
-require_relative "../lib/planka"
-require_relative "../lib/planka/client"
+# Runs as the user configured in PLANKA_AGENT_EMAIL.
+require "planka"
+require "planka/client"
 
 abort "usage: planka-claim <card>" unless ARGV.size == 1
 
 begin
   card_id = Planka.card_id(ARGV.first)
-  Planka::Client.resolve_credentials!(__FILE__, ARGV)
 
   Planka::Client.session do |client|
     me = client.me.fetch("id")

data/{bin → exe}/planka-comment

@@ -1,18 +1,16 @@
 #!/usr/bin/env ruby
 # Comments on a card as the signed-in user.
 #
-#   bin/planka-comment <card> <text>     the card as an id or card URL
+#   planka-comment <card> <text>     the card as an id or card URL
 #
-# The work-next loop runs it as its own user
-# (PLANKA_MCP_CONFIG=workflows/work-next/mcp.json).
-require_relative "../lib/planka"
-require_relative "../lib/planka/client"
+# Runs as the user configured in PLANKA_AGENT_EMAIL.
+require "planka"
+require "planka/client"
 
 abort "usage: planka-comment <card> <text>" unless ARGV.size == 2
 
 begin
   card_id = Planka.card_id(ARGV.first)
-  Planka::Client.resolve_credentials!(__FILE__, ARGV)
 
   Planka::Client.session { |client| client.comment(card_id, ARGV.last) }
 rescue Planka::Error, KeyError => e

data/{bin → exe}/planka-link

@@ -2,19 +2,18 @@
 # Records blocking edges between Planka cards as linked tasks, which the
 # planka MCP server cannot create.
 #
-#   bin/planka-link <blocked-card> <blocker-card> [<blocker-card>...]
+#   planka-link <blocked-card> <blocker-card> [<blocker-card>...]
 #
 # Cards are ids or card URLs. Each blocker becomes a task linked to that card
 # in a "Blocked by" task list on the blocked card. Re-running is safe: blockers
 # already linked are skipped. The logic lives in lib/planka/blocking.rb.
-require_relative "../lib/planka"
-require_relative "../lib/planka/client"
+require "planka"
+require "planka/client"
 
 abort "usage: planka-link <blocked-card> <blocker-card> [<blocker-card>...]" if ARGV.size < 2
 
 begin
   blocked, *blockers = ARGV.map { |arg| Planka.card_id(arg) }
-  Planka::Client.resolve_credentials!(__FILE__, ARGV)
 
   Planka::Client.session do |client|
     puts Planka::Blocking.new(client).link(blocked, blockers)

data/{bin → exe}/planka-loop-lock

@@ -3,15 +3,14 @@
 # Planka: a card on any board it can see that it has claimed, that is still
 # open, and that has no PR handed off yet. Read-only.
 #
-#   bin/planka-loop-lock     prints "free", or "held: <card>" and then
+#   planka-loop-lock     prints "free", or "held: <card>" and then
 #                            "claimed: <ISO 8601 time>" and "age: <seconds>"
 #
-# Run it as the loop's user (PLANKA_MCP_CONFIG=workflows/work-next/mcp.json).
+# Run it with the loop user's resolved credentials.
 # The logic lives in lib/planka/loop_lock.rb.
-require_relative "../lib/planka"
-require_relative "../lib/planka/client"
+require "planka"
+require "planka/client"
 
-Planka::Client.resolve_credentials!(__FILE__, ARGV)
 
 begin
   Planka::Client.session do |client|

data/{bin → exe}/planka-next-card

@@ -15,15 +15,14 @@
 #
 # The planka MCP server drops card labels and card memberships, so this reads
 # the board from Planka's API instead. The logic lives in lib/planka.
-require_relative "../lib/planka"
-require_relative "../lib/planka/client"
+require "planka"
+require "planka/client"
 
 abort "usage: planka-next-card [feature-label|effort-label]" if ARGV.size > 1
-Planka::Client.resolve_credentials!(__FILE__, ARGV)
 
 begin
   Planka::Client.session do |client|
-    board = Planka::Board.new(client.board(Planka.board_id))
+    board = Planka::Board.new(client.board(ENV.fetch("PLANKA_BOARD_ID")))
     puts Planka::NextCard.for(ARGV.first, board:, comments: client, pull_requests: Planka::PullRequest)
   end
 rescue Planka::Error, KeyError => e

data/{bin → exe}/planka-spec-sweep

@@ -4,22 +4,19 @@
 # criteria) are all in closed-type lists. Runs on every board the signed-in
 # user can see, and prints each spec it moves.
 #
-#   bin/planka-spec-sweep
+#   planka-spec-sweep
 #
-# The work-next loop runs it as its own user on every tick
-# (PLANKA_MCP_CONFIG=workflows/work-next/mcp.json). The logic lives in
-# lib/planka/spec_sweep.rb.
-require_relative "../lib/planka"
-require_relative "../lib/planka/client"
+# The logic lives in lib/planka/spec_sweep.rb.
+require "planka"
+require "planka/client"
 
-Planka::Client.resolve_credentials!(__FILE__, ARGV)
 
 begin
   Planka::Client.session do |client|
     client.board_ids.each do |board_id|
       board = Planka::Board.new(client.board(board_id))
       Planka::SpecSweep.finished(board).each do |spec|
-        client.comment(spec.id, "Every ticket for this spec is closed, so the work-next loop's housekeeping moves it to done.")
+        client.comment(spec.id, "Every ticket for this spec is closed, so planka-cli moves it to done.")
         client.move_card(spec.id, board.list_id("done"))
         puts "done: #{spec}"
       end

data/{bin → exe}/planka-unticked

@@ -1,15 +1,14 @@
 #!/usr/bin/env ruby
 # Prints a card's unticked acceptance criteria, one per line. Read-only.
 #
-#   bin/planka-unticked <card>     an id or card URL
-require_relative "../lib/planka"
-require_relative "../lib/planka/client"
+#   planka-unticked <card>     an id or card URL
+require "planka"
+require "planka/client"
 
 abort "usage: planka-unticked <card>" unless ARGV.size == 1
 
 begin
   card_id = Planka.card_id(ARGV.first)
-  Planka::Client.resolve_credentials!(__FILE__, ARGV)
 
   Planka::Client.session do |client|
     board = Planka::Board.new(client.board(client.card(card_id).dig("item", "boardId")))

data/lib/planka/board.rb

@@ -3,7 +3,10 @@ module Planka
   # as a flat list under "included", joined by id; this indexes them once so
   # a Card can answer questions about itself.
   class Board
-    def initialize(included)
+    attr_reader :base_url
+
+    def initialize(included, base_url: ENV.fetch("PLANKA_BASE_URL"))
+      @base_url = base_url.sub(%r{/+\z}, "")
       @included = included
       @cards = included.fetch("cards").to_h { |attrs| [ attrs["id"], Card.new(self, attrs) ] }
       @lists = included.fetch("lists").to_h { |list| [ list["id"], list["name"] ] }

data/lib/planka/branch_name.rb

@@ -1,24 +1,26 @@
 module Planka
   # The branch a card is worked on: feature/<slug>-<ticket#>-<title> for a
   # card with a feature label, card/<title> without one. It also names the
-  # checkout's Compose project and preview host as lucenta-<branch-label>, a
+  # checkout's Compose project and preview host with an optional prefix, a
   # DNS label of at most 63 characters, so it is cut on a word to fit.
   module BranchName
-    MAX = 63 - "lucenta-".length
+    def self.for(card, prefix: ENV.fetch("PLANKA_BRANCH_PREFIX", ""))
+      max = 63 - prefix.length
+      raise Error, "branch prefix leaves too little space" if max < 8
 
-    def self.for(card)
       feature = card.features.first&.delete_prefix("feature:")
       name = feature ? "feature/#{feature}-#{slug(card.name)}" : "card/#{slug(card.name)}"
-      fit(name)
+      fit(name, max:)
     end
 
     def self.slug(text) = text.downcase.gsub(/[^a-z0-9.]+/, "-").gsub(/\A-|-\z/, "")
 
-    def self.fit(name)
-      return name if name.length <= MAX
+    def self.fit(name, max:)
+      return name if name.length <= max
 
-      cut = name[0, MAX]
-      cut = cut[0, cut.rindex("-")] unless name[MAX] == "-" || cut.end_with?("-")
+      cut = name[0, max]
+      boundary = cut.rindex("-")
+      cut = cut[0, boundary] if boundary && name[max] != "-" && !cut.end_with?("-")
       cut.chomp("-")
     end
   end

data/lib/planka/card.rb

@@ -38,7 +38,7 @@ module Planka
     def blockers = blocking_tasks.map { |task| @board.card(task["linkedCardId"]) }
     def open_blockers = blocking_tasks.reject { |task| task["isCompleted"] }.map { |task| @board.card(task["linkedCardId"]) }
 
-    def url = Planka.card_url(id)
+    def url = "#{@board.base_url}/cards/#{id}"
     def to_s = "#{name} (#{url})"
 
     private

data/lib/planka/client.rb

@@ -1,5 +1,3 @@
-require_relative "../planka"
-require "rbconfig"
 require "json"
 require "net/http"
 require "uri"
@@ -7,31 +5,6 @@ require "uri"
 module Planka
   # A signed-in session against Planka's REST API as the board's bot user.
   class Client
-    # Configuration belongs to the calling checkout, not the installed gem.
-    # Explicit environment values take precedence over its MCP settings.
-    def self.configure!
-      path = File.expand_path(ENV.fetch("PLANKA_MCP_CONFIG", ".mcp.json"))
-      if ENV.key?("PLANKA_MCP_CONFIG") || File.file?(path)
-        config = JSON.parse(File.read(path))
-        config.fetch("mcpServers").fetch("planka").fetch("env").each do |key, value|
-          ENV[key] = value unless ENV.key?(key)
-        end
-      end
-    end
-
-    # Plain credentials need neither 1Password nor an MCP config. Secret
-    # references re-run the command through the gem's packaged shell wrapper.
-    def self.resolve_credentials!(script, argv)
-      configure!
-      %w[PLANKA_BASE_URL PLANKA_AGENT_EMAIL PLANKA_AGENT_PASSWORD].each { |key| ENV.fetch(key) }
-      return if ENV["PLANKA_CREDENTIALS_RESOLVED"]
-      return unless ENV.any? { |key, value| key.start_with?("PLANKA_") && value.start_with?("op://") }
-
-      wrapper = File.expand_path("../../bin/planka-op", __dir__)
-      exec({ "PLANKA_CREDENTIALS_RESOLVED" => "1" }, RbConfig.ruby, wrapper,
-        RbConfig.ruby, File.expand_path(script), *argv)
-    end
-
     def self.session
       client = new(ENV.fetch("PLANKA_BASE_URL"))
       client.sign_in(ENV.fetch("PLANKA_AGENT_EMAIL"), ENV.fetch("PLANKA_AGENT_PASSWORD"))

data/lib/planka/version.rb

@@ -1,3 +1,3 @@
 module Planka
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/planka-cli.rb

@@ -0,0 +1,2 @@
+require_relative "planka"
+require_relative "planka/client"

data/lib/planka.rb

@@ -1,11 +1,9 @@
 require "time"
 
-# Planka board tooling shared by the planka-* commands and workflow callers.
+# Planka board workflows, shared by the library and CLI.
 module Planka
   Error = Class.new(StandardError)
 
-  def self.board_id = ENV.fetch("PLANKA_BOARD_ID")
-  def self.card_url(id) = "#{ENV.fetch("PLANKA_BASE_URL").delete_suffix("/")}/cards/#{id}"
 
   # A card id, given as an id or a card URL.
   def self.card_id(arg)
@@ -23,3 +21,5 @@ require_relative "planka/branch_name"
 require_relative "planka/loop_lock"
 require_relative "planka/spec_sweep"
 require_relative "planka/blocking"
+
+require_relative "planka/version"