gemba-cli 0.1.0__py3-none-any.whl

gemba/worktree.py

@@ -0,0 +1,191 @@
+"""Worktree rules: the branch of a run, the repositories folder, the state of a worktree and its problems."""
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Literal
+
+# The folder of a harness that holds its worktrees, excluded from the harness repository.
+WORKTREES_DIR = "worktrees"
+# The first segment of every branch of a run when the gemba config declares no branch_prefix.
+DEFAULT_BRANCH_PREFIX = "gemba"
+# The remote of every operation.
+REMOTE = "origin"
+HEADS = "refs/heads/"
+
+# The last line each verb prints in each of its outcomes.
+CREATED = "created"
+MOVED = "moved"
+ALREADY_ATTACHED = "already attached, worktree unchanged"
+NOT_REMOVED = "not removed: pass --yes to delete the worktree"
+REMOVED = "removed"
+NO_WORKTREES = "no worktrees"
+NOT_A_WORKTREE = "not a worktree"
+UNREADABLE = "state not readable with git"
+NOT_ADDED_REFUSAL = "worktree not added:"
+NOT_MOVED_REFUSAL = "worktree not moved:"
+NOT_REMOVED_REFUSAL = "worktree not removed:"
+
+Kind = Literal["worktree", "not a worktree", "unreadable"]
+
+
+@dataclass(frozen=True)
+class Record:
+    """One worktree of a repository, as `git worktree list --porcelain` reports it."""
+
+    path: str
+    head: str | None
+    branch: str | None  # short name; None when detached or bare
+    prunable: bool
+
+
+@dataclass(frozen=True)
+class State:
+    """What a folder under `worktrees/` holds, read from git when a verb runs and never stored."""
+
+    path: str  # relative to the harness root, POSIX separators
+    kind: Kind = "worktree"
+    branch: str | None = None  # None when detached
+    upstream: str | None = None
+    uncommitted: tuple[str, ...] = ()  # each path as `git status --porcelain` names it
+    unpushed: int = 0  # commits of HEAD that are on no remote branch
+
+
+def branch_name(prefix: str, organization: str, ref: str) -> str:
+    """The local branch of every worktree of the run of `ref`."""
+    return f"{prefix}/{organization}/{ref}"
+
+
+def relative_path(repo: str) -> str:
+    """Where the worktree of `repo` lives, relative to the harness root."""
+    return PurePosixPath(WORKTREES_DIR, repo).as_posix()
+
+
+def worktree_path(harness_root: Path, repo: str) -> Path:
+    """Where the worktree of `repo` lives in the harness at `harness_root`."""
+    return harness_root / WORKTREES_DIR / repo
+
+
+def repos_dir(config_root: Path, declared: str) -> Path:
+    """The repositories folder: `declared` with `~` expanded, relative to the tasks repo root unless absolute."""
+    path = Path(declared).expanduser()
+    return path if path.is_absolute() else config_root / path
+
+
+def repo_problem(folder: Path, repo: str, repositories: Sequence[str] | None) -> str | None:
+    """Why `repo` is not a repository at the root of `folder`, or None when it is one.
+
+    `repositories` are the names of the folders directly under `folder` that hold a git
+    repository, or None when `folder` is not a folder.
+    """
+    if repositories is None:
+        return f"repos_dir {folder} is not a folder"
+    if repo in repositories:
+        return None
+    found = f"repositories there: {', '.join(sorted(repositories))}" if repositories else "no repository is there"
+    return f"no repository named '{repo}' is at the root of {folder} ({found})"
+
+
+def parse_worktrees(lines: Sequence[str]) -> list[Record]:
+    """The records of `git worktree list --porcelain`, the repository's own working tree first."""
+    records = []
+    block: list[str] = []
+    for line in [*lines, ""]:
+        if line:
+            block.append(line)
+        elif block:
+            records.append(_record(block))
+            block = []
+    return records
+
+
+def _record(block: Sequence[str]) -> Record:
+    path = head = branch = None
+    prunable = False
+    for line in block:
+        key, _separator, value = line.partition(" ")
+        if key == "worktree":
+            path = value
+        elif key == "HEAD":
+            head = value
+        elif key == "branch":
+            branch = value.removeprefix(HEADS)
+        elif key == "prunable":
+            prunable = True
+    return Record(path=path or "", head=head, branch=branch, prunable=prunable)
+
+
+def render_state(state: State) -> str:
+    """The block `list`, `remove` and the refusals of `add` print for one folder under `worktrees/`."""
+    if state.kind == "not a worktree":
+        return f"{state.path}\n{NOT_A_WORKTREE}"
+    if state.kind == "unreadable":
+        return f"{state.path}\n{UNREADABLE}"
+    return "\n".join(
+        [
+            state.path,
+            f"branch: {state.branch or 'detached'}",
+            f"upstream: {state.upstream or 'none'}",
+            f"uncommitted: {len(state.uncommitted)}",
+            f"unpushed: {state.unpushed}",
+        ]
+    )
+
+
+def pending_problems(state: State) -> list[str]:
+    """One line for the uncommitted paths and one for the unpushed commits of a worktree, when there are any."""
+    if state.kind == "not a worktree":
+        return [f"{state.path} is not a worktree"]
+    if state.kind == "unreadable":
+        return [f"the state of {state.path} could not be read with git"]
+    problems = []
+    if state.uncommitted:
+        count = _count(len(state.uncommitted), "uncommitted path")
+        problems.append(f"{state.path} has {count}: {', '.join(state.uncommitted)}")
+    if state.unpushed:
+        problems.append(f"{state.path} has {_count(state.unpushed, 'commit')} not on any remote branch")
+    return problems
+
+
+def orphan_problem(repo: str, branch: str, unpushed: int) -> str | None:
+    """Why the branch of a run left in `repo` without a worktree may not be deleted, or None when it may."""
+    if not unpushed:
+        return None
+    return f"branch {branch} of {repo} has {_count(unpushed, 'commit')} not on any remote branch and no worktree"
+
+
+def existing_branch_problem(repo: str, branch: str) -> str:
+    """The refusal of `add` when the branch of the run is already in `repo` without a worktree."""
+    return (
+        f"branch {branch} already exists in {repo} without a worktree, left by a harness deleted by hand; "
+        "--force deletes and recreates it, discarding its commits"
+    )
+
+
+def folder_problem(path: str, repo: str) -> str:
+    """The refusal of `add` when the folder of the worktree holds something else."""
+    return f"{path} exists and is not a worktree of {repo}; gemba did not put it there"
+
+
+def base_problem(from_branch: str | None, remote_branches: Sequence[str], default_branch: str | None) -> str | None:
+    """Why the base of a worktree cannot be resolved after the fetch, or None when it can."""
+    if from_branch is None and default_branch is None:
+        return f"the repository records no default branch for {REMOTE}: --from names the base branch"
+    base = from_branch or default_branch
+    if base not in remote_branches:
+        return f"{REMOTE} has no branch {base}"
+    return None
+
+
+def remote_base(branch: str) -> str:
+    """The remote-tracking branch a worktree starts from."""
+    return f"{REMOTE}/{branch}"
+
+
+def render_outcome(path: str, branch: str, base: str, verdict: str) -> str:
+    """What `add` prints when it creates or moves a worktree."""
+    return "\n".join([path, f"branch: {branch}", f"from: {remote_base(base)}", verdict])
+
+
+def _count(number: int, noun: str) -> str:
+    return f"{number} {noun}" if number == 1 else f"{number} {noun}s"

gemba_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,321 @@
+Metadata-Version: 2.5
+Name: gemba-cli
+Version: 0.1.0
+Summary: Gemba: a task-based system for working with AI agents
+Project-URL: Repository, https://github.com/web-crafts-org/gemba
+Project-URL: Changelog, https://github.com/web-crafts-org/gemba/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/web-crafts-org/gemba/issues
+Author: Manuel Robles
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-harness,agent-skills,agentic-development,ai-agents,claude-code,cli,codex,context-engineering,harness,task-management
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6
+Description-Content-Type: text/markdown
+
+# Gemba
+
+Gemba is a task-based system for working with AI agents. Every unit of work is one
+Markdown file in a repository of your own, your agent registers, launches, updates and
+closes those tasks through fixed processes, and each task is worked on inside a
+harness: a folder of its own, with its notes, its evidence and the code it touches,
+where nothing leaves without your written approval. Everything that is specific to one
+organization, its kinds of work, its fields, its rules, lives in one config file, so
+you keep one tasks repo per organization and the agent behaves the same in all of them.
+
+The name is 現場, *gemba*: "the actual place", where the work happens. In Gemba that
+place is the harness, a folder made for one task, where the agent works on it and on
+nothing else, with everything the task needs inside and none of the noise of every
+other pending thing. The task file is the logbook of that work: what was done, when,
+and what it cost, recorded day by day. The harness is where the work gets done; the
+task file is where you learn from it, the record that over time lets you see how you
+work, measure it and improve it.
+
+## The idea
+
+```
+  your tasks repo                                  the harness of one run
+  +-------------------------------------+          +--------------------------------+
+  | gemba.yaml   your organization:     |  launch  | task.md     the task, read-only|
+  |              workstreams, fields,   | -------> | notes/      what the agent     |
+  |              rules per process      |          |             found and decided  |
+  | tasks/       one file per task,     |          | assets/     the raw evidence   |
+  |              a ref like SUP-12      |  record  | worktrees/  the repositories,  |
+  | .claude/     the skills: the        | <------- |             one branch per run |
+  |   skills/    processes the agent    |          | CLAUDE.md   the guide of the   |
+  |              follows                |          |             agent              |
+  +-------------------------------------+          +--------------------------------+
+```
+
+The cycle of a task:
+
+```
+  create --> launch --> work in the harness --> record the day --> mark done
+                          notes, worktrees,         |                  |
+                          approved actions          v                  v
+                                                 report             archive,
+                                                 of the period      remove the harness
+```
+
+Three things keep it honest:
+
+- **Commands own the frontmatter, agents own the body.** The status, the dates and the
+  metadata of a task are written only by `gemba` commands; the agent writes prose.
+- **Nothing leaves the harness without an approved note.** A push, a message, a
+  deployment: the agent writes what it is about to do, and you approve it by editing
+  the note. A yes in the chat does not count.
+- **Every number comes from a command.** Counts and totals in a report are computed
+  by `gemba report`, never by the agent.
+
+Gemba works with any agent that reads skills from a folder: Claude Code
+(`.claude/skills/`) and the agents that read `.agents/skills/` (Codex, Cursor,
+Gemini CLI and others) are built in.
+
+## Install and start
+
+The only prerequisite is [uv](https://docs.astral.sh/uv/).
+
+```bash
+uv tool install gemba-cli
+gemba --version
+gemba init ~/nakatomi-tasks       # a tasks repo for the organization you work with
+```
+
+`gemba init` writes a minimal `gemba.yaml`, the `tasks/` folder, a `.gitignore` and
+the skills for every agent it knows (`--providers claude` keeps only one). It runs no
+git: make the folder a repository and commit it when you like.
+
+Then open the folder with your agent and ask it to configure Gemba. The `gemba-init`
+skill asks, one question at a time, for your organization, the kinds of work you do,
+which one takes a task that fits no other, what to record per task, your agents, your
+editor and the folder of your repositories, and writes the answers into `gemba.yaml`.
+
+From there, talk to the agent:
+
+> Register a task: login fails on Safari for Acme's checkout app.
+
+> Launch SUP-1.
+
+> Record the day on this task.
+
+> What did I do this week?
+
+## The cycle of a task
+
+Each step is a skill the agent follows and a command the skill runs. You can run the
+commands yourself too; every one of them prints what it did or every problem it found,
+at once, and exits 1 without writing anything when it refuses.
+
+### Register
+
+The `gemba-create` skill picks the workstream from the descriptions in `gemba.yaml`,
+asks for any required field you did not give, and runs:
+
+```bash
+gemba create --workstream support --slug login-fails-on-safari \
+  --description "Login fails on Safari for the checkout app" --set client=acme
+```
+
+The task file is `tasks/support/2026-09-30-SUP-1-login-fails-on-safari.md`:
+
+```markdown
+---
+status: open
+ref: SUP-1
+updated_at: 2026-09-30
+metadata:
+  client: acme
+  hours: null
+---
+
+Login fails on Safari for the checkout app
+
+## Updates
+```
+
+The ref is allocated from the highest number already used, archives included, so it
+is never reused. The metadata keys are exactly the ones declared for that workstream,
+present even when unset, each read, compared and added by the type its field declares.
+
+### Launch
+
+```bash
+gemba harness launch SUP-1
+```
+
+creates `harnesses/support/2026-09-30-SUP-1-login-fails-on-safari/` as a git
+repository of its own, with `harness.yaml`, the run's identity; `task.md`, a link to
+the task; the guide of the agent (`CLAUDE.md`, `AGENTS.md`); the harness skills;
+`notes/`, `assets/` and `worktrees/`. It moves an `open` task to `in-progress` and
+opens the folder with the `ide` command of `gemba.yaml` (`--no-open` skips it).
+Launching again only reopens it. `harnesses/` is ignored by the tasks repo: a run is
+not a record, the task is.
+
+### Work in the harness
+
+Start the agent inside the harness. The guide tells it to read the task and the notes
+first, to write before it acts, and to keep every finding, blocker, decision or
+summary as a small note, drafted as `notes/<slug>.md` and filed with the
+`gemba-harness` skill, which names it after the clock, writes its frontmatter and
+commits:
+
+```bash
+gemba harness note notes/login-trace.md --type finding --asset assets/1759350491-console.log
+```
+
+An `external-action` note describes, word for word, something to be done outside the
+harness. Nothing happens until you set `approved: true` in its frontmatter from your
+editor. After acting, the agent writes the outcome into the note and runs
+`gemba harness resolve notes/<file>.md`, which records when.
+
+When the task touches code, the agent checks out the repositories it needs as git
+worktrees, each on a local branch named after the run:
+
+```bash
+gemba worktree add nakatomi-web                      # from the default branch of origin
+gemba worktree add nakatomi-web --from release/2.4   # from another branch, or move to it
+gemba worktree list                                  # branch, upstream, uncommitted, unpushed
+gemba worktree remove nakatomi-web --yes             # the worktree and its branch
+```
+
+A repository is a folder under the `repos_dir` of `gemba.yaml`; Gemba never clones.
+The branch, `gemba/nakatomi/SUP-1`, exists only on your machine and is never pushed
+under its own name: a push needs an approved note naming the branch of the remote, and
+always names its target, `git push -u origin HEAD:<that branch>`. `add --from` and
+`remove` refuse while anything is uncommitted or on no remote branch; `--force`
+discards it, and the agent passes it only after you confirm what the command listed.
+
+### Record the day
+
+At the end of the day, ask the agent to record the day on the task. It distills the
+notes of that date into a few bullets in `update.md` at the harness root and runs:
+
+```bash
+gemba record update.md                     # today
+gemba record update.md --date 2026-09-30   # a past day
+```
+
+The bullets land under `### 2026-09-30` in the task's `## Updates` section,
+`updated_at` moves forward, and the draft is deleted. Nothing is committed: the tasks
+repo is yours to review and commit.
+
+### Report
+
+Ask the agent in the tasks repo for yesterday, for a day, a week or a month. The
+`gemba-report` skill finds the tasks alive in the period with `gemba list`, reads the
+subsections dated in it, groups what it finds by workstream, and lists the tasks
+updated recently with nothing recorded. Every count and total comes from:
+
+```bash
+gemba report --done-from 2026-09-01 --done-to 2026-09-30 --by client --sum hours
+```
+
+which takes the filters of `gemba list`, groups with `--by` (`workstream`, `status`,
+or a text or boolean field) and adds number fields with `--sum`, exactly.
+
+### Close out
+
+Three steps, each on its own, each asking before it deletes anything:
+
+```bash
+gemba mark SUP-1 done                  # done today: done_at and updated_at move
+gemba mark SUP-1 open                  # reopened: done_at is removed
+gemba harness remove SUP-1             # show what the run holds, delete nothing
+gemba harness remove SUP-1 --yes       # delete the harness, its worktrees and branches
+gemba archive SUP-1 OPS-2              # move each task file into archive/
+```
+
+A task done today can be reopened tomorrow in the same harness; a run can be thrown
+away on a task still in progress; a task is archived only once it went cold, and only
+after its harness is gone. Archived tasks leave `gemba list` unless
+`--include-archived` is given.
+
+### Keep the metadata
+
+The hours grow, the work gets invoiced. Tell the agent, from the tasks repo or inside
+the harness, and the `gemba-set` skill runs:
+
+```bash
+gemba set SUP-1 hours+=2                # added to the number the task holds
+gemba set SUP-1 invoiced=2026-10-03     # a value, written by the type of its field
+gemba set SUP-1 merge_requests=null     # cleared
+```
+
+It rewrites only the metadata, never `updated_at`, and refuses an undeclared key or a
+value of the wrong type.
+
+## The config
+
+`gemba.yaml` is edited by hand, or by the `gemba-config` skill when you ask the agent
+to add a workstream, a field or a rule; `gemba config check` validates it and
+`gemba config show` prints it resolved, as the skills read it. No command rewrites it.
+
+```yaml
+default_workstream: operations
+
+agent_providers: [claude, agents]
+
+ide: code -n
+organization: nakatomi
+repos_dir: ~/projects
+
+metadata:
+  - { name: client, type: text, required: true, description: Who the work is for }
+  - { name: hours, type: number, description: Total hours spent on the task }
+  - { name: invoiced, type: date, description: When the work was invoiced }
+
+harness:
+  guide: |
+    Client data never leaves the harness: strip it from every asset you save.
+
+workstreams:
+  support:
+    prefix: SUP
+    description: Investigate a client-reported problem and deliver a report or a fix
+    worktree:
+      add:
+        rules:
+          - start from the branch deployed to production; ask when the task does not say it
+  operations:
+    prefix: OPS
+    description: Anything that does not fit another workstream
+```
+
+What you can customize, all of it here and never in a skill:
+
+- **Workstreams**, each with a prefix, a description the agent uses to choose one, and
+  its own fields, and the one that takes a task that fits no other.
+- **Metadata fields**, shared or per workstream, each of one type: `text`, `number`,
+  `boolean` or `date`. Gemba reads, filters, groups and adds values by their type and
+  never interprets their meaning.
+- **Agent providers**, the IDE command, the organization and the repositories folder.
+- **`context` and `rules` for every process**, at the top level and per workstream:
+  what the agent should know and do when it creates, lists, launches, notes, records,
+  marks, archives or checks out, with the workstream's rule winning a contradiction.
+- **The guide** of every harness, with a paragraph of your organization and one of
+  the workstream.
+
+Changing any of it is a config edit: no skill and no code changes.
+
+## Status
+
+Gemba is young, at version 0.x, and built from daily use: the whole cycle above
+works, and the shape of the commands may still change between minor versions, with
+the changelog saying so. Ideas, questions and reports of what got in your way are the
+most useful contribution right now: see [CONTRIBUTING.md](CONTRIBUTING.md), which also
+describes how the product is developed, by specification, one case per scenario.
+
+## License
+
+[MIT](LICENSE).

gemba_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+gemba/__init__.py,sha256=RbNI2zl3aSluYz39uAM5jHQt8BNYbz9uogMktlS3t3Y,61
+gemba/cli.py,sha256=zbPZTEB6OIgzD_n5bNxE66tHakW32NdzzGAfzgANHn8,1432
+gemba/config.py,sha256=QD_y0Sq2HTp_R9QRfgTJbXsXru3JQaZBHu3JBPJh6Ng,15710
+gemba/harness.py,sha256=_WXUm-PfmRgNw8yKo9X4E1AYZe319R_ddBM-kpWyYTc,16531
+gemba/metadata.py,sha256=MOqeXJNF9ebiE_FaVLc-FJEx4LVMXV5e_yJdTQVo7TE,18639
+gemba/repo.py,sha256=UZwiPtQ93IFyb40HsG79ztUpdKekQIH6_iIq1vFq_CA,3246
+gemba/report.py,sha256=VVkmiNs3iXValnIJ_00euTTwaxalLEUCnnEFvc7kkno,5383
+gemba/skills.py,sha256=DYLe70HW8Y30A9KGTOI2rKw95uFTh40P_YlUTpB3aGg,7018
+gemba/tasks.py,sha256=X2MnLIfv6Z_xHFVPaAulx1VtNY62u_J1UzjQqhVTUA4,25647
+gemba/values.py,sha256=fY80Pif69R81B0wGA5XSNEHgCdlYob_NrDJ1qBepXQk,438
+gemba/worktree.py,sha256=IQJhEaH1OMOcKxbxoXBN1lEUaxgiwCqqVqX_bLEym6I,7379
+gemba/assets/harness/guide.md,sha256=-Ze-Vsd3Ldwd2xfCRj30WCBgQaRv0jwPWVR24BS7x-c,4287
+gemba/assets/init/gemba.yaml,sha256=Oq6ZqClnBRx04hk2dBUcquO7DnHJfJnbdGifDHnlmaY,409
+gemba/assets/skills/gemba-archive/SKILL.md,sha256=MaGiAvcaJD19ISyN4oxkAEBWe9TqGn4X0MwmglHiNPo,4111
+gemba/assets/skills/gemba-config/SKILL.md,sha256=UwY70PFahtBwGVN6JIly5qmEfJ8rGAPy-x2caTqGDRM,9394
+gemba/assets/skills/gemba-create/SKILL.md,sha256=1qiHjBPrX9l7bifBdd3cTLXXMcmxn4En4XtZB2IjsiY,5628
+gemba/assets/skills/gemba-harness/SKILL.md,sha256=e86Fb57z2HUSrFxkQipog01ti1zKrINPG_xUeGbbPKk,10817
+gemba/assets/skills/gemba-init/SKILL.md,sha256=mAte9xxflqBY7DAJTcaBjgk3YHTIjU4WIEPrXeg6_QQ,4718
+gemba/assets/skills/gemba-list/SKILL.md,sha256=EhSV5RhRj-JMEF5n9gqjlLd9ptf8yBJ3F4icp_yK3ck,8320
+gemba/assets/skills/gemba-mark/SKILL.md,sha256=VYHG38I7KIGG6p0eSF8sFBoIFK70vqxyhAy68jlreRQ,4894
+gemba/assets/skills/gemba-record/SKILL.md,sha256=93xEfUJGQpARRxeu9QwtAO-ezUPS__-enfvYMfrvRzM,5387
+gemba/assets/skills/gemba-report/SKILL.md,sha256=Lt79TdgSecgLhDpVJiu5ISz3ilz3R1nrGGbomX8_QNQ,8891
+gemba/assets/skills/gemba-set/SKILL.md,sha256=3nLnPvLazMRcGDBNtnaRzx9fl16NsqYFznKdz4JwvYc,6114
+gemba/assets/skills/gemba-worktree/SKILL.md,sha256=8DAiM-9ozaXfwilUJQkt8j6Ov-V3FReSUQAnmpM3nNY,7395
+gemba/commands/__init__.py,sha256=wr8mNC2UTAyTRKdNZqm7Dd6YEPHzvHuCJa-PmpZW_yc,77
+gemba/commands/archive.py,sha256=2lbUvSCYquyzU3jYmR_mgJQgYzASJR7wPsG9fTlCIiQ,2538
+gemba/commands/config.py,sha256=e6m8rTAJFROYnb5jClI94koRasXGe9qzz6dqRQvzeYU,4829
+gemba/commands/create.py,sha256=eVMCqUS1YX6QOTf4-orOhx0EkeQgD7Y02CPIDAmnbhM,4255
+gemba/commands/harness.py,sha256=Wnzhz7iAUUvWe8EKM86N7sd7qwTlpAWL38T6CQWhymg,23877
+gemba/commands/init.py,sha256=3tNIKGlZEHGY6vdukG5zwGDdUsFmNnWf82upni8zL8s,4227
+gemba/commands/list.py,sha256=oiIMKHh34Br3YIgT3lNheB1pSINB1XLvs0gvyrJVyRo,1825
+gemba/commands/mark.py,sha256=t7sLg9Ydiuz1__JffuMObwuEAJYt_10nBOoChkkWmsw,3659
+gemba/commands/record.py,sha256=XHXxa8nBBREmrDcqCRBKMNOX7yepxWlNXHTxcjqvSng,4600
+gemba/commands/report.py,sha256=Ac_qCwJ_KYTBVBsgCRccI9pxJxLYclhYFsVqQzmtD-0,2959
+gemba/commands/selection.py,sha256=wJdwZ95RojvNm7Q5DzPsdpyOZV9a5VrA3qWGUV6wGUA,6624
+gemba/commands/set.py,sha256=Y4Jru2yllSgAVG83P59Roe766ippYbuUIjOUGLvvj3k,3218
+gemba/commands/skills.py,sha256=P8xaY8G9kG1PUsPTvY0uCXlJO6DHYuS9V-caeU_VIVc,4150
+gemba/commands/worktree.py,sha256=aWyfQBy54rNJAlFxRQ78b4Ox2xhwygW9FNvFbC4_v38,14051
+gemba_cli-0.1.0.dist-info/METADATA,sha256=xCxcHZN7QXwpfcsZcYIiMGeKQDwvoRYRGwQgUrOg5G0,13597
+gemba_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+gemba_cli-0.1.0.dist-info/entry_points.txt,sha256=aqxtvtHmslMud8S7z-VhfmV08CGQwUUV-DxJ6ndN46s,41
+gemba_cli-0.1.0.dist-info/licenses/LICENSE,sha256=8cwPq1tG0xQjpUO9ENcmVO0l-i8rUAqryZu1EPK3Oo0,1070
+gemba_cli-0.1.0.dist-info/RECORD,,

gemba_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

gemba_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gemba = gemba.cli:main

gemba_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Manuel Robles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.