git-reviewer 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dheeraj Jha
+
+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.

package/README.md

@@ -0,0 +1,282 @@
+# reviewer
+
+[![CI](https://github.com/dheerajjha/reviewer/actions/workflows/ci.yml/badge.svg)](https://github.com/dheerajjha/reviewer/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](package.json)
+[![Tests](https://img.shields.io/badge/tests-163-brightgreen.svg)](test/)
+[![Dependencies](https://img.shields.io/badge/dependencies-3-brightgreen.svg)](package.json)
+
+![Plain grey code lines on the left resolving into colored diff stripes, with threaded comment markers attached in the right margin](docs/banner.jpg)
+
+Review code before it becomes a pull request. `reviewer` opens any local git
+repository in your browser, shows what changed, and lets you leave inline
+comments with threaded follow-ups — against your working directory, without a
+branch, a remote, a push, or an account. Comments persist between sessions and
+survive the code moving underneath them, so you can review, edit, and come back
+tomorrow to a review that still points at the right lines. When you are done it
+writes a plain Markdown file you can paste anywhere.
+
+```bash
+cd ~/work/my-app
+npx git-reviewer .
+```
+
+That starts a local server and opens your browser on the repository you named.
+There is nothing to install into the project, nothing to sign in to, and
+nothing leaves your machine.
+
+![The app reviewing a modified file: changed files on the left, a colour-coded diff in the middle with an inline comment and a threaded follow-up attached to line 10, and a comments sidebar on the right](docs/screenshot-comments.png)
+
+Click a line number, write the note, keep going. Replies thread under the
+comment they answer, and everything is saved as you type.
+
+## Usage
+
+```
+reviewer [repository] [options]
+reviewer export [repository] [--format json|prompt]
+
+  repository        Path to a git repository (default: the current directory)
+
+  -p, --port <n>    Port to listen on (default 4500; falls back to a free
+                    port if that one is taken)
+      --no-open     Print the URL instead of opening a browser
+  -f, --format <f>  Export format: json (default) or prompt
+  -h, --help        Show help
+  -v, --version     Show the version
+```
+
+```bash
+reviewer                    # review the repository you are standing in
+reviewer ~/work/api         # review another one
+reviewer . --no-open        # print the URL, open it yourself
+reviewer . --port 8080      # somewhere other than 4500
+```
+
+Two at once is fine — the second one finds its own port.
+
+To install it as a command rather than running it through `npx`:
+
+```bash
+npm install -g git-reviewer
+reviewer .
+```
+
+The package is `git-reviewer` because `reviewer` and `code-reviewer` were both
+already taken on npm. The command it installs is still `reviewer` -- the
+package name is a distribution detail, the command is the product.
+
+From a clone, if you would rather not install anything:
+
+```bash
+git clone https://github.com/dheerajjha/reviewer.git
+cd reviewer && npm install && npm link
+```
+
+## What it shows you
+
+`reviewer` picks what to review based on the state of the repository, so there
+is nothing to configure:
+
+| Repository state | What you review |
+|---|---|
+| Uncommitted changes present | Your working directory against `HEAD` |
+| Working directory clean | The last commit against its parent |
+| No commits yet | Every tracked and untracked file, as wholly new |
+
+Modified, added, deleted, renamed, and binary files are all listed, each marked
+with its git status letter. Deleted lines are commentable too — the most useful
+review note is often about the code someone removed. A file deleted outright is
+shown in full, read back out of `HEAD`:
+
+![The app showing a deleted file, every line rendered as a removal, recovered from HEAD because the file is no longer on disk](docs/screenshot-deleted.png)
+
+## Reviewing
+
+| Action | How |
+|---|---|
+| Comment on a line | Click the line number |
+| Comment on a snippet | Hold `Cmd/Ctrl`, select code, then click the line number |
+| Reply to a comment | Click **Reply** on it |
+| Edit or delete | Hover the comment |
+| Finish the review | Click **Submit Review** |
+
+| Shortcut | Action |
+|---|---|
+| `Cmd/Ctrl+Enter` | Save the comment being written |
+| `Escape` | Cancel input |
+| `↑` / `↓` | Move between files |
+
+## What it writes
+
+Two files, both under `reviews/`, both plain text you can read without this
+app:
+
+- **`.code-review-comments-<repo>.json`** — the live state of the review. It is
+  written on every edit and is the source of truth; reopening the same
+  repository restores exactly what is in it.
+- **`review_<repo>_<timestamp>.txt`** — a submitted review, rendered from that
+  JSON as Markdown, grouped by file and ordered by line:
+
+````markdown
+# Code Review
+
+Repository: /work/my-app
+Generated: 2026-08-10T12:30:45.678Z
+Total Comments: 2
+
+## src/auth.js
+
+**Line 42:**
+```
+  const token = req.headers.authorization;
+```
+This trusts the header without checking the scheme.
+
+**Follow-ups:**
+  1. Still open after the rebase (2026-08-10T14:02:11.000Z)
+````
+
+Timestamps are ISO 8601 rather than a locale format on purpose: a review gets
+committed, pasted into a pull request, and read on someone else's machine, so
+its shape should not depend on the reader.
+
+Submitting shows you exactly what was written, ready to download or copy:
+
+![The Review Submitted dialog showing the rendered Markdown review, with a download button naming the file review_api-service_2026-08-10_17-40-48-989Z.txt](docs/screenshot-review.png)
+
+## Handing the review to a coding agent
+
+A review is only half the work; applying it is the other half. `reviewer
+export` prints the review you saved — no server, no submit step — either as
+JSON or as instructions ready to pipe:
+
+```bash
+reviewer export . --format prompt | claude -p "Apply this review to the repo."
+reviewer export . | jq '.comments[].file'
+```
+
+Every comment carries an `anchor`: the exact text of the line it was left on.
+Line numbers go stale the moment an agent makes its first edit, because
+everything below shifts — so the anchor is what lets a comment still be found.
+The prompt format says so to the agent explicitly, and tells it to report
+rather than guess when an anchor has vanished.
+
+```json
+{
+  "schema": "code-review/v1",
+  "repository": { "path": "/work/api-service", "head": "abe3b37", "branch": "main" },
+  "summary": { "comments": 2, "files": 1 },
+  "comments": [
+    {
+      "id": "src/auth.js:10",
+      "file": "src/auth.js",
+      "line": 10,
+      "anchor": "  if (scheme !== SCHEME || !token) return null;",
+      "body": "Reject an empty token too.",
+      "followUps": [{ "body": "Still open after the rebase", "at": "2026-08-10T14:00:00.000Z" }]
+    }
+  ]
+}
+```
+
+Submitting in the UI writes this alongside the `.txt`. The full schema is in
+[docs/agent-format.md](docs/agent-format.md).
+
+## HTTP API
+
+The UI is a client of this; nothing is hidden from you.
+
+| Endpoint | Purpose |
+|---|---|
+| `GET /api/health` | Liveness, plus the number of open sessions |
+| `POST /api/load-repo` | Open a repository; returns a `repoId` and the changed files |
+| `GET /api/file/:repoId/:path` | The file's diff, as structured lines |
+| `GET /api/file-full/:repoId/:path` | Every line of the file, for context |
+| `POST /api/save-comments` | Persist the current comments |
+| `GET /api/load-comments/:repoId` | Restore saved comments |
+| `POST /api/submit-review` | Render the saved comments to a review file |
+| `DELETE /api/cleanup/:repoId` | End the session; files on disk are untouched |
+
+A `repoId` is a random per-session handle, not a path. Requests that resolve
+outside the opened repository are refused, and a path that names nothing gets a
+404.
+
+`npm run serve` starts the server on its own, without opening a browser.
+
+## Security
+
+The server binds to `127.0.0.1`. It reads any file in the repository you
+opened, so reaching it should require being on the machine running it — set
+`HOST=0.0.0.0` only if you mean it. Every path that reaches the filesystem is
+resolved through a check that it lands inside that repository, so a request for
+`..%2f..%2fetc%2fpasswd` is refused rather than served.
+
+If you find a way past that, please report it through
+[security advisories](https://github.com/dheerajjha/reviewer/security/advisories/new)
+rather than a public issue.
+
+## Development
+
+```bash
+npm install           # 3 dependencies, no build step, ~6MB
+npm test              # 163 tests
+npm run test:watch
+npm run test:coverage
+```
+
+```
+bin/reviewer.js  the command: parse args, start server, open browser
+server.js        Express app factory and routes
+lib/
+  cli.js           argument parsing and URL building
+  browser.js       opening a URL on each platform
+  diff.js          unified diff -> structured lines
+  paths.js         confines request paths to the repository
+  changes.js       git status and commit summaries -> changed files
+  comments.js      the persisted comment shape
+  review.js        rendering and naming review files
+  sessions.js      repoId -> repository
+public/          UI: index.html, style.css, app.js
+test/            Node test runner; HTTP tests drive real git repositories
+```
+
+The request handlers hold no logic worth testing — it lives in `lib/`, and
+`server.js` exports `createApp()` so a test can point an instance at a
+temporary directory. The HTTP tests do not stub git: each one builds a real
+repository in a temp directory and runs real `git` against it, because diff
+parsing is exactly where a stub would be wrong in the same way the code is.
+
+Tests run on Linux and macOS across Node 18, 20, and 22. See
+[CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Tech
+
+Express, [simple-git](https://github.com/steveukx/git-js), and vanilla
+JavaScript in the browser. Three runtime dependencies, no dev dependencies, no
+build step for the frontend, no test framework — the tests use the one built
+into Node.
+
+Version 2.0 dropped the Electron wrapper. It added a few hundred megabytes and
+a per-platform build pipeline to put a browser engine around a page your
+browser already renders. See [CHANGELOG.md](CHANGELOG.md).
+
+## Contributing
+
+There is a list of [open issues](https://github.com/dheerajjha/reviewer/issues),
+including some tagged
+[good first issue](https://github.com/dheerajjha/reviewer/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
+The ones most likely to change how the tool feels:
+
+- [#1](https://github.com/dheerajjha/reviewer/issues/1) — reviews are stored inside the install rather than with the repository
+- [#2](https://github.com/dheerajjha/reviewer/issues/2) — give comments a state, so a review can be worked through and marked off
+- [#3](https://github.com/dheerajjha/reviewer/issues/3) — report whether each anchor still matches the file
+- [#4](https://github.com/dheerajjha/reviewer/issues/4) — expose the review over MCP, so an agent works through it interactively
+- [#6](https://github.com/dheerajjha/reviewer/issues/6) — review a commit range, not just the working tree
+
+[CONTRIBUTING.md](CONTRIBUTING.md) covers the setup and what a good change looks
+like here.
+
+## License
+
+[MIT](LICENSE) © Dheeraj Jha

package/bin/reviewer.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs').promises;
+const path = require('path');
+
+const simpleGit = require('simple-git');
+
+const { parseArgs, buildUrl, UsageError, USAGE } = require('../lib/cli');
+const { openInBrowser } = require('../lib/browser');
+const { buildReviewDocument, filterReviewDocument, formatPrompt } = require('../lib/agent');
+const { readSavedComments, ReviewOwnershipError } = require('../lib/store');
+const { startServer, DEFAULT_PORT, DEFAULT_HOST, REVIEWS_DIR } = require('../server');
+const { version } = require('../package.json');
+
+/**
+ * The `reviewer` command: start the local server and open it in a browser.
+ */
+
+/**
+ * Listen on `port`, falling back to any free port if it is taken.
+ *
+ * Someone reviewing two repositories at once should get a second window, not
+ * an EADDRINUSE stack trace.
+ *
+ * @param {number} port
+ * @returns {Promise<import('http').Server>}
+ */
+async function listen(port) {
+  try {
+    return await startServer({ port, host: DEFAULT_HOST, silent: true });
+  } catch (error) {
+    if (error.code !== 'EADDRINUSE') throw error;
+
+    console.log(`Port ${port} is in use, picking another.`);
+    return startServer({ port: 0, host: DEFAULT_HOST, silent: true });
+  }
+}
+
+/**
+ * Print the saved review of a repository to stdout.
+ *
+ * Reads the same JSON the UI writes on every edit, so a review can be handed
+ * to another tool without submitting it or keeping the server running.
+ *
+ * @param {import('../lib/cli').CliOptions} options
+ */
+async function exportReview(options) {
+  const repoPath = options.repoPath ?? process.cwd();
+
+  let comments;
+  try {
+    ({ comments } = await readSavedComments(REVIEWS_DIR, repoPath));
+  } catch (error) {
+    if (error instanceof ReviewOwnershipError) throw new UsageError(error.message);
+    throw error;
+  }
+
+  if (comments.length === 0) {
+    throw new UsageError(`No saved review for ${repoPath}. Review it first, then export.`);
+  }
+
+  // Recording the commit lets a consumer tell whether the tree has moved on
+  // since the review was written. Neither is fatal if git will not say.
+  const git = simpleGit(repoPath);
+  const head = await git.revparse(['HEAD']).then(sha => sha.trim()).catch(() => null);
+  const branch = await git.revparse(['--abbrev-ref', 'HEAD']).then(name => name.trim()).catch(() => null);
+
+  const document = filterReviewDocument(
+    buildReviewDocument({
+      repoPath,
+      comments,
+      generatedAt: new Date(),
+      head,
+      branch
+    }),
+    { file: options.file }
+  );
+
+  if (document.comments.length === 0) {
+    throw new UsageError(`The saved review for ${repoPath} has no comments for ${options.file}.`);
+  }
+
+  process.stdout.write(
+    options.format === 'prompt'
+      ? formatPrompt(document)
+      : `${JSON.stringify(document, null, 2)}\n`
+  );
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (options.help) {
+    process.stdout.write(USAGE);
+    return;
+  }
+
+  if (options.version) {
+    console.log(version);
+    return;
+  }
+
+  if (options.repoPath) {
+    try {
+      await fs.access(options.repoPath);
+    } catch {
+      throw new UsageError(`No such directory: ${options.repoPath}`);
+    }
+  }
+
+  if (options.command === 'export') {
+    return exportReview(options);
+  }
+
+  const server = await listen(options.port ?? (Number(process.env.PORT) || DEFAULT_PORT));
+  const url = buildUrl(`http://${DEFAULT_HOST}:${server.address().port}`, options.repoPath);
+
+  console.log(`\n  Code Reviewer  ${url}`);
+  if (options.repoPath) console.log(`  reviewing      ${options.repoPath}`);
+  console.log('\n  Press Ctrl+C to stop.\n');
+
+  if (options.open && !(await openInBrowser(url))) {
+    console.log('  Could not open a browser — open the URL above yourself.\n');
+  }
+
+  const stop = () => {
+    server.close(() => process.exit(0));
+    // Don't wait forever on a browser holding the connection open.
+    setTimeout(() => process.exit(0), 2000).unref();
+  };
+
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+}
+
+main().catch(error => {
+  if (error instanceof UsageError) {
+    console.error(`error: ${error.message}\n`);
+    process.stderr.write(USAGE);
+    process.exit(2);
+  }
+
+  console.error(error);
+  process.exit(1);
+});

package/lib/agent.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const { groupByFile } = require('./comments');
+const { repoSlug } = require('./review');
+
+/**
+ * The machine-readable form of a review.
+ *
+ * The `.txt` review is written for a person to read. A coding agent asked to
+ * act on a review needs something else: a stable schema, and above all an
+ * *anchor* — the exact text of the line a comment was left on. Line numbers
+ * are the first thing to go stale, because the agent's own first edit shifts
+ * every line below it. The anchor is what lets a comment still be found after
+ * that.
+ */
+
+const SCHEMA = 'code-review/v1';
+
+/**
+ * @typedef {object} ReviewDocument
+ * @property {string} schema
+ * @property {string} generatedAt ISO 8601
+ * @property {{path: string, name: string, head: string|null, branch: string|null}} repository
+ * @property {'working'|'lastCommit'|null} mode
+ * @property {{comments: number, files: number}} summary
+ * @property {AgentComment[]} comments
+ */
+
+/**
+ * @typedef {object} AgentComment
+ * @property {string} id stable within a document
+ * @property {string} file repo-relative path
+ * @property {number} line line number when the comment was written
+ * @property {string|null} anchor the exact source line, for relocating the comment
+ * @property {string} [selection] the snippet the reviewer highlighted
+ * @property {string} body
+ * @property {Array<{body: string, at?: string}>} [followUps]
+ */
+
+/**
+ * Build the machine-readable review document.
+ *
+ * @param {object} args
+ * @param {string} args.repoPath
+ * @param {import('./comments').Comment[]} args.comments
+ * @param {Date} args.generatedAt
+ * @param {string|null} [args.head] the commit the review was written against
+ * @param {string|null} [args.branch]
+ * @param {string|null} [args.mode]
+ * @returns {ReviewDocument}
+ */
+function buildReviewDocument({ repoPath, comments, generatedAt, head = null, branch = null, mode = null }) {
+  const grouped = groupByFile(comments);
+
+  return {
+    schema: SCHEMA,
+    generatedAt: generatedAt.toISOString(),
+    repository: {
+      path: repoPath,
+      name: repoSlug(repoPath),
+      head,
+      branch
+    },
+    mode,
+    summary: {
+      comments: comments.length,
+      files: grouped.length
+    },
+    comments: grouped.flatMap(([, fileComments]) => fileComments.map(toAgentComment))
+  };
+}
+
+/**
+ * Select comments from an already-built document and keep its summary honest.
+ *
+ * @param {ReviewDocument} document
+ * @param {object} filters
+ * @param {string|null} [filters.file]
+ * @returns {ReviewDocument}
+ */
+function filterReviewDocument(document, { file = null } = {}) {
+  if (file === null) return document;
+
+  const comments = document.comments.filter(comment => comment.file === file);
+  return {
+    ...document,
+    summary: {
+      comments: comments.length,
+      files: new Set(comments.map(comment => comment.file)).size
+    },
+    comments
+  };
+}
+
+/**
+ * @param {import('./comments').Comment} comment
+ * @returns {AgentComment}
+ */
+function toAgentComment(comment) {
+  const entry = {
+    // File and line identify a comment uniquely — the UI anchors one comment
+    // per line — and staying derived keeps ids stable across exports.
+    id: `${comment.file}:${comment.line}`,
+    file: comment.file,
+    line: comment.line,
+    anchor: comment.lineContent ?? null,
+    body: comment.text
+  };
+
+  if (comment.selectedText) entry.selection = comment.selectedText;
+
+  if (comment.followUps?.length > 0) {
+    entry.followUps = comment.followUps.map(followUp => {
+      const item = { body: followUp.text };
+      if (followUp.timestamp) item.at = followUp.timestamp;
+      return item;
+    });
+  }
+
+  return entry;
+}
+
+/**
+ * Render a review as instructions for a coding agent.
+ *
+ * This is the format meant to be piped straight into a tool like Claude Code.
+ * It leads with what to do and how to locate each comment, because an agent
+ * reads top-down and the instruction has to arrive before the data it governs.
+ *
+ * @param {ReviewDocument} document
+ * @returns {string}
+ */
+function formatPrompt(document) {
+  const { repository, summary } = document;
+  const lines = [
+    '# Code review to address',
+    '',
+    `Repository: ${repository.path}`,
+    repository.head ? `Reviewed at commit: ${repository.head}` : null,
+    `${summary.comments} comment(s) across ${summary.files} file(s), written ${document.generatedAt}.`,
+    '',
+    'Work through every comment below and make the change it asks for, or, if',
+    'you disagree, say why and leave the code alone. Comments are grouped by',
+    'file and ordered by line.',
+    '',
+    'Line numbers are from when the review was written, so treat them as a',
+    'hint: locate each comment by its `anchor` line instead, since your own',
+    'edits will shift everything below them. If an anchor no longer appears in',
+    'the file, say so rather than guessing at the intended location.',
+    ''
+  ].filter(line => line !== null);
+
+  let currentFile = null;
+  for (const comment of document.comments) {
+    if (comment.file !== currentFile) {
+      currentFile = comment.file;
+      lines.push(`## ${currentFile}`, '');
+    }
+
+    lines.push(`### ${comment.id}`, '');
+    if (comment.anchor !== null) {
+      lines.push('Anchor line:', '', '```', comment.anchor, '```', '');
+    }
+    if (comment.selection) {
+      lines.push('Selected code:', '', '```', comment.selection, '```', '');
+    }
+
+    lines.push(comment.body, '');
+
+    if (comment.followUps?.length > 0) {
+      lines.push('Follow-ups:', '');
+      comment.followUps.forEach((followUp, index) => {
+        lines.push(`${index + 1}. ${followUp.body}`);
+      });
+      lines.push('');
+    }
+  }
+
+  return `${lines.join('\n')}`;
+}
+
+module.exports = { buildReviewDocument, filterReviewDocument, formatPrompt, SCHEMA };

package/lib/browser.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const childProcess = require('child_process');
+
+/**
+ * Opening a URL in the user's default browser.
+ */
+
+/**
+ * The command that opens a URL on this platform.
+ *
+ * @param {string} platform a `process.platform` value
+ * @param {string} url
+ * @returns {{command: string, args: string[]}}
+ */
+function openCommand(platform, url) {
+  switch (platform) {
+    case 'darwin':
+      return { command: 'open', args: [url] };
+    case 'win32':
+      // `start` is a cmd builtin, not an executable. Its first quoted argument
+      // is taken as the window title, so an empty one has to come first or the
+      // URL itself would be swallowed as the title.
+      return { command: 'cmd', args: ['/c', 'start', '', url] };
+    default:
+      return { command: 'xdg-open', args: [url] };
+  }
+}
+
+/**
+ * Open a URL in the default browser.
+ *
+ * Failure here is not worth interrupting anyone over — a headless machine has
+ * no browser to open, and the caller has already printed the URL — so this
+ * resolves either way and reports what happened.
+ *
+ * @param {string} url
+ * @param {object} [options]
+ * @param {string} [options.platform] defaults to the running platform
+ * @param {typeof childProcess.spawn} [options.spawn] injectable for tests
+ * @returns {Promise<boolean>} whether the opener was launched
+ */
+function openInBrowser(url, options = {}) {
+  const { platform = process.platform, spawn = childProcess.spawn } = options;
+  const { command, args } = openCommand(platform, url);
+
+  return new Promise(resolve => {
+    try {
+      const child = spawn(command, args, { stdio: 'ignore', detached: true });
+
+      // A missing opener fails asynchronously — spawn does not throw for it —
+      // so success has to wait for the 'spawn' event rather than assume it.
+      // Reporting success either way would make the caller's fallback message
+      // unreachable on exactly the machines that need it.
+      child.on('error', () => resolve(false));
+      child.on('spawn', () => {
+        // Let the opener outlive this process rather than hold the event loop.
+        child.unref();
+        resolve(true);
+      });
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+module.exports = { openInBrowser, openCommand };