@programinglive/dev-workflow-mcp-server 1.1.6 → 1.1.11

package/CHANGELOG.md

@@ -2,6 +2,57 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.1.11](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.1.10...v1.1.11) (2025-10-30)
+
+
+### 🧹 Chores
+
+* verify run_full_workflow with persisted project summary ([6fdb475](https://github.com/programinglive/dev-workflow-mcp-server/commit/6fdb475f65ee6ef2c061b0b1cf954a282406e2a1))
+
+
+### ✨ Features
+
+* add per-user state, SQLite project summary, and dashboard ([7b57b6e](https://github.com/programinglive/dev-workflow-mcp-server/commit/7b57b6e067ad59f2999a2badcb51b1293192c96b))
+* per-project workflow state with unique per-user IDs; smarter workflow ([b710a52](https://github.com/programinglive/dev-workflow-mcp-server/commit/b710a524997583f58cd6da2567ba9fd14abdd3c9))
+
+### [1.1.10](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.1.9...v1.1.10) (2025-10-29)
+
+
+### ✨ Features
+
+* add project knowledge library with persisted summary file for future database integration ([b9dc13f](https://github.com/programinglive/dev-workflow-mcp-server/commit/b9dc13f4b25dec756088a55185ccbfdb3988a644))
+
+### [1.1.9](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.1.8...v1.1.9) (2025-10-29)
+
+
+### 🧹 Chores
+
+* interim commit ([b1aead0](https://github.com/programinglive/dev-workflow-mcp-server/commit/b1aead05920c766a183988fb93d3f0edc3e1eafc))
+
+
+### ✅ Tests
+
+* update README.md, exec.js, package-lock.json +7 more ([894fdf1](https://github.com/programinglive/dev-workflow-mcp-server/commit/894fdf1eace33ddf0081c565028d214e1c7697bf))
+
+
+### ✨ Features
+
+* make run_full_workflow smart and resumable from current phase ([930eb3c](https://github.com/programinglive/dev-workflow-mcp-server/commit/930eb3cb84c241b14f0e194cf490313e1e99a7ce))
+
+### [1.1.8](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.1.7...v1.1.8) (2025-10-27)
+
+
+### 📝 Documentation
+
+* note DEV_WORKFLOW_STATE_FILE override ([bbeb11b](https://github.com/programinglive/dev-workflow-mcp-server/commit/bbeb11bc7f8be33f7c1a51b336283a3b2a48d3ea))
+
+### [1.1.7](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.1.6...v1.1.7) (2025-10-26)
+
+
+### ✨ Features
+
+* prompt for documentation after tests pass ([a87e44f](https://github.com/programinglive/dev-workflow-mcp-server/commit/a87e44f2a78ea4c9220d62868ee1f9c7ad3b149b))
+
 ### [1.1.6](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.1.5...v1.1.6) (2025-10-26)
 
 

package/README.md

@@ -24,7 +24,7 @@ Each project gets its own isolated workflow state file.
 npm install @programinglive/dev-workflow-mcp-server
 ```
 
-This will automatically create a `.workflow-state.json` file in the **project where you ran `npm install`** (using npm's `INIT_CWD`), keeping workflow history separate per project. If you're installing the package itself (inside `node_modules`), the script skips creation so it never pollutes the shared package directory.
+This will automatically create a `.state/workflow-state.json` file in the **project where you ran `npm install`** (using npm's `INIT_CWD`), keeping workflow history separate per project. If you're installing the package itself (inside `node_modules`), the script skips creation so it never pollutes the shared package directory.
 
 ### Option 2: Install from Source
 
@@ -34,6 +34,11 @@ cd dev-workflow-mcp-server
 npm install
 ```
 
+#### Two Usage Modes
+
+- **Local (source)**: Point your MCP client to `index.js`. This runs directly from source and requires no build step. Recommended for MCP usage.
+- **Production (built)**: Run `npm run build` once to generate `dist/`. This creates an optimized bundle but isn’t needed for MCP usage.
+
 ### 3. Configure in Windsurf/Claude Desktop
 
 Point your MCP client to the server entry point. Replace `<PROJECT_ROOT>` with the absolute path to this repository on your machine.
@@ -128,27 +133,109 @@ Point your MCP client to the server entry point. Replace `<PROJECT_ROOT>` with t
 
 After adding the configuration, restart the application to load the MCP server.
 
+## 🏗️ Build System
+
+This project includes a Vite-based build system for creating optimized distributions.
+
+### Scripts
+
+- `npm run build` - Bundle the source into `dist/index.mjs` for distribution
+- `npm run dev` - Run in development mode with file watching
+- `npm run local` - Alias for running from source (same as `npm start`)
+
+### Build Output
+
+Running `npm run build` generates:
+- `dist/index.mjs` - Optimized ES module bundle
+- Source maps and other build artifacts
+
+The build bundles all source files while externalizing Node.js built-in modules and dependencies, resulting in a single file distribution.
+
+### Usage
+
+For MCP server usage, point your client at `index.js` (source) to avoid stdio transport compatibility issues. The built `dist/index.mjs` is primarily for:
+- npm package distribution
+- Performance optimization
+- Embedding in other projects
+
 ## 📁 Project-Specific Workflow State
 
-When you install this package in a project, a `.workflow-state.json` file is automatically created in your project root. This file:
+When you install this package in a project, a `.state/workflow-state.json` file is automatically created in your project root. This file:
 
 - **Stores workflow history** specific to that project
 - **Tracks task progress** independently per project
 - **Should be gitignored** (already in `.gitignore` by default)
 - **Persists across sessions** so your workflow state is preserved
+- **Stays centralized** even if you run the server from nested build outputs like `dist/`. The MCP server walks back to the project root (looking for `.git` or `package.json`) before reading or writing workflow state, so you never need duplicate copies under build directories.
 
-Each project maintains its own isolated workflow history, so you can work on multiple projects without mixing their histories.
+Each project maintains its own isolated workflow history, so you can work on multiple projects without mixing their histories. Within that `.state` directory, the MCP server automatically creates a unique per-user subdirectory (e.g., `.state/users/user-abc123/`). The generated identifier persists locally so multiple developers sharing the same repository never clobber each other’s workflow files. If you prefer a specific name, set `DEV_WORKFLOW_USER_ID` before launching the server and that value will be used instead of the auto-generated ID.
 
 ### Adding to .gitignore
 
 If you're using this package, add this to your project's `.gitignore`:
 
 ```
-.workflow-state.json
+.state/
 ```
 
 This keeps workflow state local to each developer's machine.
 
+> **Need to override the location?** Set `DEV_WORKFLOW_STATE_FILE=/absolute/path/to/your/project/.state/workflow-state.json` before launching the server (or inside your MCP client config). The server will honor that path, letting you keep the package installed centrally while maintaining per-project workflow history.
+
+## 🛠️ Available Tools
+
+- `start_task` - Begin a new coding task
+- `mark_bug_fixed` - Mark the feature/bug as fixed (requires tests next)
+- `create_tests` - Mark that tests have been created
+- `skip_tests` - Skip tests with justification
+- `run_tests` - Record test results (must pass to proceed)
+- `create_documentation` - Mark documentation as created
+- `check_ready_to_commit` - Verify all steps are complete
+- `commit_and_push` - Commit and push changes
+- `perform_release` - Record release details
+- `complete_task` - Mark task as complete and reset
+- `force_complete_task` - Force completion with reason
+- `drop_task` - Abandon current task
+- `get_workflow_status` - Show current status
+- `view_history` - View completed tasks
+- `continue_workflow` - Get next-step guidance
+- `rerun_workflow` - Reset and restart the current task from the beginning
+- `run_full_workflow` - Execute every workflow step in sequence with a single command (requires supplying the details for each phase)
+
+### `run_full_workflow`
+
+Use this when you already have all the information needed for each workflow phase and want to execute them in one go.
+
+```json
+{
+  "summary": "Add payment webhooks",
+  "testCommand": "npm test",
+  "documentationType": "README",
+  "documentationSummary": "Document webhook configuration",
+  "commitMessage": "feat: add payment webhooks",
+  "releaseCommand": "npm run release:minor",
+  "releaseNotes": "Release webhook support",
+  "branch": "feature/payments",
+  "testsPassed": true,
+  "testDetails": "node --test; 42 tests",
+  "releaseType": "minor",
+  "preset": "minor"
+}
+```
+
+The tool will:
+
+1. `mark_bug_fixed` using `summary`
+2. `create_tests`
+3. `run_tests` with `testsPassed`, `testCommand`, and optional `testDetails`
+4. `create_documentation` with `documentationType` and `documentationSummary`
+5. `check_ready_to_commit`
+6. `commit_and_push` with `commitMessage` and optional `branch`
+7. `perform_release` with `releaseCommand`, plus optional `releaseNotes`, `releaseType`, and `preset`
+8. `complete_task` reusing `commitMessage`
+
+All arguments except the optional flags are required and must be non-empty strings.
+
 ## 🚫 Releasing Without the Workflow Steps
 
 The package ships with a release guard (`release-wrapper.js`) that backs the `npm run release:*` scripts. The guard refuses to run unless:
@@ -372,7 +459,7 @@ You can modify the workflow in `index.js`:
 
 ## 📝 State Management
 
-The server maintains state in `.workflow-state.json`:
+The server maintains state in `.state/workflow-state.json`:
 - Current phase
 - Task description
 - Completion status of each step

package/db/index.js

@@ -0,0 +1,204 @@
+import Database from "better-sqlite3";
+import { existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DB_FILENAME = "dev-workflow.db";
+const FREQUENCY_FORMATS = {
+  daily: "%Y-%m-%d",
+  monthly: "%Y-%m",
+  yearly: "%Y",
+};
+
+function getDbPath() {
+  const initCwd = process.env.INIT_CWD || process.cwd();
+  let projectRoot = initCwd;
+  while (projectRoot !== path.dirname(projectRoot)) {
+    if (existsSync(path.join(projectRoot, "package.json"))) break;
+    projectRoot = path.dirname(projectRoot);
+  }
+  return path.join(projectRoot, ".state", DB_FILENAME);
+}
+
+let db;
+export function getDb() {
+  if (!db) {
+    const dbPath = getDbPath();
+    db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    migrate();
+  }
+  return db;
+}
+
+function migrate() {
+  const createHistory = `
+    CREATE TABLE IF NOT EXISTS workflow_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id TEXT NOT NULL,
+      task_description TEXT NOT NULL,
+      task_type TEXT NOT NULL,
+      commit_message TEXT,
+      timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+      forced INTEGER DEFAULT 0,
+      force_reason TEXT,
+      dropped INTEGER DEFAULT 0,
+      drop_reason TEXT,
+      UNIQUE(user_id, timestamp, task_description)
+    )
+  `;
+  const createSummary = `
+    CREATE TABLE IF NOT EXISTS project_summary (
+      user_id TEXT PRIMARY KEY,
+      total_tasks INTEGER DEFAULT 0,
+      task_types TEXT DEFAULT '{}',
+      last_active DATETIME,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      recent_tasks TEXT DEFAULT '[]'
+    )
+  `;
+  const idxHistory = `CREATE INDEX IF NOT EXISTS idx_workflow_history_user ON workflow_history(user_id)`;
+  const idxSummary = `CREATE INDEX IF NOT EXISTS idx_project_summary_user ON project_summary(user_id)`;
+
+  db.exec(createHistory);
+  db.exec(createSummary);
+  db.exec(idxHistory);
+  db.exec(idxSummary);
+}
+
+export function insertHistoryEntry(userId, entry) {
+  const stmt = getDb().prepare(`
+    INSERT OR REPLACE INTO workflow_history
+    (user_id, task_description, task_type, commit_message, timestamp, forced, force_reason, dropped, drop_reason)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    userId,
+    entry.taskDescription,
+    entry.taskType,
+    entry.commitMessage,
+    entry.timestamp || new Date().toISOString(),
+    entry.forced ? 1 : 0,
+    entry.forceReason || null,
+    entry.dropped ? 1 : 0,
+    entry.dropReason || null
+  );
+  updateSummaryForUser(userId);
+}
+
+export function updateSummaryForUser(userId) {
+  const getHistory = getDb().prepare(`
+    SELECT task_type, timestamp, task_description
+    FROM workflow_history
+    WHERE user_id = ?
+    ORDER BY timestamp DESC
+    LIMIT 20
+  `);
+  const rows = getHistory.all(userId);
+
+  const taskTypes = {};
+  for (const row of rows) {
+    taskTypes[row.task_type] = (taskTypes[row.task_type] || 0) + 1;
+  }
+
+  const recentTasks = rows.slice(0, 5).map(r => ({
+    description: r.task_description,
+    type: r.task_type,
+    timestamp: r.timestamp,
+  }));
+
+  const lastActive = rows[0]?.timestamp || null;
+
+  const upsert = getDb().prepare(`
+    INSERT OR REPLACE INTO project_summary
+    (user_id, total_tasks, task_types, last_active, recent_tasks, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  upsert.run(
+    userId,
+    rows.length,
+    JSON.stringify(taskTypes),
+    lastActive,
+    JSON.stringify(recentTasks),
+    new Date().toISOString()
+  );
+}
+
+export function getSummaryForUser(userId) {
+  const stmt = getDb().prepare(`
+    SELECT * FROM project_summary WHERE user_id = ?
+  `);
+  const row = stmt.get(userId);
+  if (!row) return null;
+  return {
+    totalTasks: row.total_tasks,
+    taskTypes: JSON.parse(row.task_types),
+    lastActive: row.last_active,
+    recentTasks: JSON.parse(row.recent_tasks),
+    updatedAt: row.updated_at,
+  };
+}
+
+function buildHistoryFilters({ startDate, endDate }) {
+  const clauses = [];
+  const params = [];
+  if (startDate) {
+    clauses.push("DATE(timestamp) >= DATE(?)");
+    params.push(startDate);
+  }
+  if (endDate) {
+    clauses.push("DATE(timestamp) <= DATE(?)");
+    params.push(endDate);
+  }
+  return { clauses, params };
+}
+
+export function getHistoryForUser(userId, options = {}) {
+  const { page = 1, pageSize = 20, startDate, endDate } = options;
+  const sanitizedPage = Math.max(1, Number.isFinite(Number(page)) ? Math.floor(Number(page)) : 1);
+  const sanitizedPageSize = Math.min(100, Math.max(1, Number.isFinite(Number(pageSize)) ? Math.floor(Number(pageSize)) : 20));
+  const offset = (sanitizedPage - 1) * sanitizedPageSize;
+
+  const { clauses, params } = buildHistoryFilters({ startDate, endDate });
+  const where = ["user_id = ?", ...clauses].join(" AND ");
+  const dbInstance = getDb();
+
+  const countStmt = dbInstance.prepare(`SELECT COUNT(*) as total FROM workflow_history WHERE ${where}`);
+  const total = countStmt.get(userId, ...params).total;
+
+  const rowsStmt = dbInstance.prepare(`
+    SELECT *
+    FROM workflow_history
+    WHERE ${where}
+    ORDER BY timestamp DESC
+    LIMIT ?
+    OFFSET ?
+  `);
+  const entries = rowsStmt.all(userId, ...params, sanitizedPageSize, offset);
+
+  return {
+    entries,
+    total,
+    page: sanitizedPage,
+    pageSize: sanitizedPageSize,
+  };
+}
+
+export function getHistorySummary(userId, options = {}) {
+  const { startDate, endDate, frequency = "daily" } = options;
+  const format = FREQUENCY_FORMATS[frequency] || FREQUENCY_FORMATS.daily;
+  const { clauses, params } = buildHistoryFilters({ startDate, endDate });
+  const where = ["user_id = ?", ...clauses].join(" AND ");
+  const stmt = getDb().prepare(`
+    SELECT strftime('${format}', timestamp) AS period, COUNT(*) AS count
+    FROM workflow_history
+    WHERE ${where}
+    GROUP BY period
+    ORDER BY period DESC
+  `);
+  return stmt
+    .all(userId, ...params)
+    .map((row) => ({ period: row.period, count: row.count }));
+}

package/exec.js

@@ -1,4 +1,49 @@
 import { exec as execCallback } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
 import { promisify } from "util";
 
-export const exec = promisify(execCallback);
+const execPromise = promisify(execCallback);
+
+function findRepoRoot(startDir) {
+  if (!startDir) {
+    return null;
+  }
+
+  let current = path.resolve(startDir);
+  const { root } = path.parse(current);
+
+  while (true) {
+    if (existsSync(path.join(current, ".git"))) {
+      return current;
+    }
+
+    if (current === root) {
+      return null;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+
+    current = parent;
+  }
+}
+
+function getDefaultCwd() {
+  const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+  const candidateDirs = [process.cwd(), process.env.INIT_CWD, moduleDir];
+  return candidateDirs.reduce((resolved, candidate) => {
+    if (resolved) {
+      return resolved;
+    }
+    return findRepoRoot(candidate) || null;
+  }, null) || process.cwd();
+}
+
+export function exec(command, options = {}) {
+  const execOptions = options.cwd ? options : { ...options, cwd: getDefaultCwd() };
+  return execPromise(command, execOptions);
+}

package/index.js

@@ -32,8 +32,7 @@ export { createCommitMessageParts, determineReleaseTypeFromCommit } from "./comm
 export { containsTestFilesInStatus, workingTreeSummary } from "./git-helpers.js";
 export { WorkflowState } from "./workflow-state.js";
 
-export const workflowState = new WorkflowState();
-await workflowState.load();
+export let workflowState = null;
 
 const __filename = fileURLToPath(import.meta.url);
 
@@ -184,6 +183,17 @@ Use 'check_ready_to_commit' to verify workflow completion.
 
 // Start server
 export async function main() {
+  try {
+    // Initialize workflow state
+    workflowState = new WorkflowState();
+    await workflowState.load();
+    await workflowState.ensurePrimaryFile();
+  } catch (error) {
+    console.error("Warning: Failed to initialize workflow state:", error.message);
+    // Continue anyway - workflow state is optional for MCP to function
+    workflowState = new WorkflowState();
+  }
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error("Dev Workflow MCP Server running on stdio");

package/install.js

@@ -25,7 +25,11 @@ async function install() {
       return;
     }
 
-    const stateFile = path.join(projectRoot, '.workflow-state.json');
+    const stateDir = path.join(projectRoot, '.state');
+    const stateFile = path.join(stateDir, 'workflow-state.json');
+
+    // Create .state directory if it doesn't exist
+    await fs.mkdir(stateDir, { recursive: true });
 
     // Check if state file already exists
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.1.6",
+  "version": "1.1.11",
   "description": "MCP server to enforce development workflow discipline",
   "type": "module",
   "main": "index.js",
@@ -8,16 +8,19 @@
     "dev-workflow-mcp": "index.js"
   },
   "scripts": {
+    "build": "vite build",
+    "dev": "node --watch index.js",
+    "start": "node index.js",
+    "local": "node index.js",
     "test": "node --test",
     "check": "node --check index.js",
-    "start": "node index.js",
-    "dev": "node --watch index.js",
     "prepare": "husky",
     "postinstall": "node install.js",
     "release": "standard-version",
     "release:major": "node release-wrapper.js major",
     "release:minor": "node release-wrapper.js minor",
-    "release:patch": "node release-wrapper.js patch"
+    "release:patch": "node release-wrapper.js patch",
+    "web": "node web/server.js"
   },
   "keywords": [
     "mcp",
@@ -28,7 +31,13 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^11.8.0",
+    "esbuild": "^0.25.0",
+    "get-port": "^7.1.0",
+    "husky": "^9.1.7",
+    "standard-version": "^9.5.0",
+    "vite": "^7.1.12"
   },
   "publishConfig": {
     "access": "public"
@@ -36,9 +45,7 @@
   "devDependencies": {
     "@commitlint/cli": "^20.1.0",
     "@commitlint/config-conventional": "^20.0.0",
-    "@programinglive/commiter": "^1.0.0",
-    "husky": "^9.1.7",
-    "standard-version": "^9.5.0"
+    "@programinglive/commiter": "^1.1.0"
   },
   "standard-version": {
     "releaseCommitMessageFormat": "chore(release): {{currentTag}} 🚀",

package/release-wrapper.js

@@ -22,7 +22,7 @@ async function main() {
     process.exit(1);
   }
 
-  const statePath = path.join(projectRoot, '.workflow-state.json');
+  const statePath = path.join(projectRoot, '.state', 'workflow-state.json');
   let state;
 
   try {

package/tests/build.test.js

@@ -0,0 +1,37 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { readFile, access } from 'fs/promises';
+import { exec as execCallback } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+
+const exec = promisify(execCallback);
+
+test('build generates dist/index.mjs file', async () => {
+  const { stderr } = await exec('npm run build');
+  // Allow the known vite warning about node:process
+  const knownWarning = '[plugin vite:resolve] Module "node:process" has been externalized for browser compatibility';
+  const actualStderr = stderr.replace(/\x1B\[[0-9;]*m/g, ''); // Remove ANSI codes
+  assert(
+    actualStderr === '' || actualStderr.includes(knownWarning),
+    `Build should not have unexpected errors: ${actualStderr}`
+  );
+  
+  // Verify the file exists
+  const distPath = path.join(process.cwd(), 'dist', 'index.mjs');
+  await access(distPath);
+  
+  // Verify it contains expected content
+  const content = await readFile(distPath, 'utf-8');
+  assert(content.includes('main'), 'Bundle should contain main function');
+  assert(content.length > 1000, 'Bundle should be substantial');
+});
+
+test('build script exists in package.json', async () => {
+  const packagePath = path.join(process.cwd(), 'package.json');
+  const content = await readFile(packagePath, 'utf-8');
+  const pkg = JSON.parse(content);
+  
+  assert.strictEqual(typeof pkg.scripts.build, 'string');
+  assert(pkg.scripts.build.includes('vite build'));
+});

package/tests/exec.test.js

@@ -0,0 +1,32 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { exec } from '../exec.js';
+import { tmpdir } from 'os';
+import { mkdtemp, rm } from 'fs/promises';
+import path from 'path';
+
+test('exec runs commands successfully', async () => {
+  const { stdout } = await exec('echo "hello world"');
+  assert.strictEqual(stdout.trim(), 'hello world');
+});
+
+test('exec respects explicit cwd option', async () => {
+  const tempDir = await mkdtemp(path.join(tmpdir(), 'mcp-test-'));
+  
+  try {
+    const { stdout } = await exec('pwd', { cwd: tempDir });
+    // Just verify it runs in the specified directory (path may vary by platform)
+    assert(stdout.trim().includes('mcp-test-'));
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('exec handles command errors', async () => {
+  try {
+    await exec('command-that-does-not-exist');
+    assert.fail('Should have thrown an error');
+  } catch (error) {
+    assert(error.code !== undefined || error.message.includes('command-not-found'));
+  }
+});