npm - command-code - Versions diffs - 1.4.1 → 1.4.3 - Mend

command-code 1.4.1 → 1.4.3

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 (18) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "command-code",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "Command Code, coding agent that continuously learns your coding taste. Best coding agent for open models.",
   "type": "module",
   "engines": {
@@ -109,13 +109,13 @@
     "tsup": "^8.5.0",
     "vitest": "^4.1.6",
     "vitest-ansi-serializer": "^0.2.1",
+    "@commandcode/harness": "0.1.0",
     "@commandcode/provider-anthropic": "0.1.0",
     "@commandcode/provider-openai": "0.1.0",
-    "@commandcode/shared": "0.0.1",
-    "@commandcode/providers": "0.1.0",
+    "@commandcode/provider-copilot": "0.1.0",
     "@commandcode/tui": "0.1.0",
-    "@commandcode/harness": "0.1.0",
-    "@commandcode/provider-copilot": "0.1.0"
+    "@commandcode/shared": "0.0.1",
+    "@commandcode/providers": "0.1.0"
   },
   "scripts": {
     "prebuild": "test -f vsix/commandcode-vscode.vsix || bash ../../scripts/build-ext.sh",

package/vsix/commandcode-vscode.vsix CHANGED Viewed

Binary file

package/dist/bundled/command-code-knowledge/reference/plan-review.md DELETED Viewed

@@ -1,226 +0,0 @@
-<!-- GENERATED FILE — do not edit. Source: packages/docs/src/app/core-concepts/plan-review/page.mdx. Regenerate: pnpm generate:knowledge -->
-# Plan Review
-Plan review is the full-screen surface where Command Code presents a written plan for your sign-off — a code-review experience for plans, in the terminal. New in **v1**, it turns a plan into a first-class, persistent artifact you can read, comment on, revise, and approve, instead of a block of text that scrolls away.
-If you've reviewed a pull request on GitHub, plan review will feel familiar: one plan line is always selected, you leave inline comments, and you resolve the plan with a verb — **Submit review**, **Approve**, or **Cancel**.
-Plan review pairs with [Plan Mode](./plan-mode.md). Plan mode is where the agent *writes* the plan; plan review is where you *sign off* on it.
----
-## At a glance
-- **One mode: REVIEW.** Read line by line, comment on any line, resolve with a verb. There is no separate "edit mode" — plan edits go through your `$EDITOR`.
-- **Plans persist.** Every plan is saved to `~/.commandcode/plans/` as markdown and indexed, so canceling a review never throws the plan away.
-- **Comments are review artifacts, not plan text.** They live in a sidecar overlay and only reach the agent inside a prompt — they never get written into the plan document.
-- **GitHub-style verbs.** Submit review (`ctrl+r`), Approve (`ctrl+a`) or Execute plan (`ctrl+e`), Cancel/Back (`esc`).
-- **Review rounds.** When the agent revises a plan, the next round diffs against the last one — changed lines render green so you re-review only what moved.
-- **Deterministic.** A harness backstop guarantees the review is offered even when a weaker model writes a plan and simply stops.
----
-## How it works
-A plan starts in plan mode, lands in review, and loops until you approve it. Submitting a review sends it back to the agent for a revision; approving implements it; canceling saves it for later.
-```
-  You: "plan a rate limiter"
-        │
-        ▼
-  ┌──────────────┐   agent explores (read-only) and writes
-  │  PLAN MODE   │   ~/.commandcode/plans/rate-limiter.md
-  └──────┬───────┘
-         │ exit_plan_mode  (or plan_review / /plan-review / the backstop)
-         ▼
-  ┌───────────────────────────┐        revised plan (round N+1)
-  │   PLAN REVIEW  ·  REVIEW   │◀─────────────────────────┐
-  │   read · comment · revise  │                          │
-  └──┬──────────┬──────────┬───┘                   ┌──────┴──────┐
-     │          │          │                        │ agent       │
- Submit review  │          │  ── comments ─────────▶│ revises the │
- (ctrl+r) ──────┘          │                        │ plan        │
-     ▲                     │                        └─────────────┘
-     └── another round ────┘
-                           │
-             Approve (ctrl+a) / Execute (ctrl+e)
-                           │
-                           ▼
-                    ┌─────────────┐
-                    │  IMPLEMENT  │
-                    └─────────────┘
-  Cancel (esc) ──▶ plan saved · status: not-implemented
-                   reopen anytime with /plans
-```
-Inside the reader, one line is always selected, comments pin inline under their line, and the pinned bottom bar holds the review verbs:
-```
-┌ Plan review: Rate limiter · ~/.commandcode/plans/rate-limiter.md · v2 ┐
-│                                                                       │
-│   3   ## Approach                        ← headings / code styled     │
-│   4                                                                   │
-│   5 ● 1. Add a token-bucket middleware.  ← ● marks a commented line   │
-│       ↳ why not a sliding window?        ← your inline comment        │
-│   6   2. Store buckets in Redis.                                      │
-│   7   3. Return 429 with Retry-After.    ← green if changed (round 2) │
-│                                                                       │
-│ ───────────────────────────────────────────────────────────────────  │
-│  REVIEW   1 pending comment  ·  round 2 · 1 line changed              │
-│  Submit review (1)  ctrl+r   agent revises the plan, returns it       │
-│  Approve            ctrl+a   executes the plan · comments go as notes │
-│  Cancel             esc                                               │
-│  type + enter to comment · ctrl+n/p jump changes · quick: ? x ! · ^g  │
-└───────────────────────────────────────────────────────────────────── ┘
-```
----
-## Opening plan review
-There are four ways into the same review surface. All of them are scoped to a plan written during the **current session**.
-### 1. Finishing plan mode
-While in [plan mode](./plan-mode.md), the agent writes the plan to `~/.commandcode/plans/<name>.md` and then calls `exit_plan_mode`. That opens plan review as the approval surface — the plan *is* the approval prompt. Approving here can also switch you into [auto-accept mode](./plan-mode.md#auto-accept-mode) so implementation runs without further prompts.
-### 2. Asking to review a plan (`plan_review` tool)
-Outside plan mode, just ask:
-> "review plan" · "open plan review" · "show me the plan"
-The agent calls the `plan_review` tool, which opens the review panel for the most recent plan file. This exists so the agent shows you the real review surface instead of pasting the plan back as a wall of text. In plan mode the agent uses `exit_plan_mode` instead — there is exactly one review path per mode.
-### 3. The `/plan-review` slash command
-Run `/plan-review` to jump straight into a review of **this session's latest plan**.
-### 4. The `/plans` browser
-Run `/plans` to open the full-screen plan browser — every plan from this session and past sessions, with status badges, comment counts, and search. Open any plan to read and review it. `/plans <name>` jumps straight into a named plan.
-### The automatic backstop (auto plan review)
-Some models write a plan file and stop without ever presenting it. Command Code makes the review a guarantee, not a courtesy: when a run ends naturally with a plan that was written but never reviewed (in **default** or **plan** mode), the harness presents the same review panel itself. Approving it continues the run with an instruction to implement; declining lets the run end so you can steer. Modes that mean "don't interrupt me" — auto-accept, bypass, and dont-ask — skip the backstop.
----
-## Reviewing a plan
-The reader renders the plan like a document — headings, code, quotes, and tables are styled per line. One line is always highlighted. The bottom of the screen holds a fixed zone: a **REVIEW** badge with the pending-comment count, a single context-sensitive hint line, and the stacked review verbs. Nothing in that zone changes as you scroll — your position lives in the highlight and the gutter line number.
-### Navigating
-| Key | Action |
-|-----|--------|
-| `↑` / `↓` | Move one line; past the last line drops onto the review verbs |
-| `PgUp` / `PgDn` (`Fn+↑/↓` on Mac) | Page up/down one viewport, like `less` |
-| `Home` / `End` (`Fn+←/→` on Mac) | Jump the cursor to the first / last line |
-| `ctrl+n` / `ctrl+p` | Jump between marked lines — your comments, plus changed lines in a revised plan |
-Long lines **wrap** at a comfortable reading width (80 columns when there's room, otherwise 60) rather than truncating, so you can always read the full paragraph.
-### Leaving comments
-Commenting is Figma-style — just start typing on a line and a draft comment box opens **inline, directly under that line**, exactly where it will sit once pinned.
-| Key | Action |
-|-----|--------|
-| type + `Enter` | Open a draft on the selected line, then pin it |
-| `Enter` on a commented line | Reopen the comment to edit it |
-| empty + `Enter` | Remove the comment |
-| `?` | Quick comment: "Why? Explain the reasoning behind this." |
-| `x` | Quick comment: "Cut this — remove it from the plan." |
-| `!` | Quick comment: "Risky — double-check this before implementing." |
-| `esc` (while drafting) | Discard the draft |
-Pinned comments show a `●` gutter marker on the line and a `↳ comment` row beneath it. Comments are saved to disk with the plan, so they survive closing the reader and even ending the session. They never become part of the plan document.
-### Editing the plan
-Plan review has no separate edit mode. Press `ctrl+g` to hand the plan file to your `$EDITOR` (from `$EDITOR`/`$VISUAL`); the reader reloads when you close it. The editor is the edit surface, the reader is the review surface.
----
-## Resolving a review
-The review verbs are stacked in the pinned bottom bar. Trigger them by chord from anywhere, or arrow onto them and press `Enter`.
-| Verb | Chord | What it does |
-|------|-------|--------------|
-| **Submit review** | `ctrl+r` | The agent takes your pending comments, revises the plan, and re-presents it for another round. Only shown when you have pending comments. |
-| **Approve** *(approval surface)* | `ctrl+a` | Executes the plan and begins implementation. If you have pending comments, they ride along as notes (see below). |
-| **Execute plan** *(browser surface)* | `ctrl+e` | Executes the plan as written — from the `/plans` browser this is itself an approval, so the agent implements directly. |
-| **Cancel** / **Back** | `esc` | Ends the review. In plan mode the plan stays saved and you keep refining; from the browser it returns to the list. |
-### Approving with pending comments
-If you press Approve while comments are still pending, Command Code doesn't guess. It asks:
-```
-Approve  (•) with N comments as notes    ( ) original plan · discard comments
-```
-Choose **with comments as notes** and your comments are sent as a follow-up user turn — non-blocking notes the agent implements against. Choose **original plan** to approve it clean and drop the comments. Use `←/→` to switch, `Enter` to confirm, `esc` to back out.
----
-## Review rounds and versioning
-Plan review is iterative. Each time you **Submit review**, Command Code:
-1. Snapshots the current plan to `~/.commandcode/plans/versions/<name>-v<N>.md`.
-2. Bumps the plan's version and clears your pending comments (they were all handed to the agent in one prompt).
-3. Lets the agent revise the plan, overwriting the live file.
-When the revised plan comes back (version > 1), the reader **diffs it against the previous round's snapshot**. Changed lines render **green**, and the badge line reports `round N · M lines changed` — so a second review means re-reading only what actually moved, not the whole plan again. `ctrl+n`/`ctrl+p` jump between those changed lines.
----
-## Where plans live
-Plans and their metadata are stored under your home directory:
-```
-~/.commandcode/plans/<descriptive-name>.md     ← the plan markdown (written by the agent)
-~/.commandcode/plans/plans-index.json          ← titles, status, comments, versions
-~/.commandcode/plans/versions/<name>-v<N>.md    ← prior review-round snapshots
-```
-Every plan carries a status:
-- **pending** — written but not yet taken through review.
-- **approved** — you approved it and moved to implementation.
-- **not-implemented** — you canceled the review; the plan is kept for later reading, commenting, and revision.
-Because a canceled plan is recorded rather than discarded, planning never feels throwaway — reopen it any time with `/plans`. Writes to `~/.commandcode/plans/*.md` never prompt for permission (in any mode), and only `.md` files there get that exemption, so the plans directory can't double as a scratchpad.
----
-## Slash commands
-| Command | Description |
-|---------|-------------|
-| `/plan` | Enter plan mode; `/plan <task>` plans that task |
-| `/plans` | Browse, review, and comment on saved plans — `/plans [name]` opens one directly |
-| `/plan-review` | Open plan review on this session's latest plan |
-| `/mode plan` | Switch to plan mode (read-only, no side effects) |
----
-## Related tools
-- **`exit_plan_mode`** — presents the plan for approval when leaving plan mode. Only valid *in* plan mode.
-- **`plan_review`** — opens the review panel on demand *outside* plan mode. Renders as `PLAN(review)` in the activity feed.
-- **`enter_plan_mode`** — switches into plan mode (with your confirmation) for read-only exploration.
----
-## Next steps
-- Learn how [Plan Mode](./plan-mode.md) and Auto-Accept mode split reasoning from execution.
-- Use [Checkpoints](./checkpoints.md) to rewind after an approved plan is implemented.
-- Browse the full [Slash Commands](https://commandcode.ai/docs/reference/slash-commands) and [Tools](https://commandcode.ai/docs/reference/tools) references.