@staff0rd/assist 0.21.2 → 0.22.1

package/README.md

@@ -35,6 +35,7 @@ After installation, the `assist` command will be available globally.
 - `assist sync` - Copy command files to `~/.claude/commands`
 - `assist commit <message>` - Create a git commit with validation
 - `assist prs` - List pull requests for the current repository
+- `assist prs comments <pr-number>` - List all comments on a pull request
 - `assist run <name>` - Run a configured command from assist.yml
 - `assist run add` - Add a new run configuration to assist.yml
 - `assist update` - Update claude-code to the latest version
@@ -51,6 +52,11 @@ After installation, the `assist` command will be available globally.
 - `assist devlog version` - Show current repo name and version info
 - `assist vscode init` - Add VS Code configuration files
 - `assist deploy init` - Initialize Netlify project and configure deployment
+- `assist deploy redirect` - Add trailing slash redirect script to index.html
 - `assist notify` - Show desktop notification from JSON stdin (supports macOS, Windows, WSL)
 - `assist status-line` - Format Claude Code status line from JSON stdin
+- `assist complexity cyclomatic [pattern]` - Calculate cyclomatic complexity per function
+- `assist complexity halstead [pattern]` - Calculate Halstead metrics per function
+- `assist complexity maintainability [pattern]` - Calculate maintainability index per file
+- `assist complexity sloc [pattern]` - Count source lines of code per file
 

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { execSync as execSync14 } from "child_process";
+import { execSync as execSync16 } from "child_process";
 import { Command } from "commander";
 
 // src/commands/commit.ts
@@ -1004,69 +1004,11 @@ function version() {
   console.log(`${chalk13.bold("next:")} ${nextVersion ?? chalk13.dim("none")}`);
 }
 
-// src/commands/enable-ralph/index.ts
-import * as fs4 from "fs";
-import * as path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import chalk14 from "chalk";
-var __dirname3 = path2.dirname(fileURLToPath2(import.meta.url));
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const sourceVal = source[key];
-    const targetVal = result[key];
-    if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal && typeof targetVal === "object" && !Array.isArray(targetVal)) {
-      result[key] = deepMerge(
-        targetVal,
-        sourceVal
-      );
-    } else {
-      result[key] = sourceVal;
-    }
-  }
-  return result;
-}
-async function enableRalph() {
-  const sourcePath = path2.join(
-    __dirname3,
-    "commands/enable-ralph/settings.local.json"
-  );
-  const targetPath = path2.join(process.cwd(), ".claude/settings.local.json");
-  const sourceData = JSON.parse(fs4.readFileSync(sourcePath, "utf-8"));
-  const targetDir = path2.dirname(targetPath);
-  if (!fs4.existsSync(targetDir)) {
-    fs4.mkdirSync(targetDir, { recursive: true });
-  }
-  let targetData = {};
-  let targetContent = "{}";
-  if (fs4.existsSync(targetPath)) {
-    targetContent = fs4.readFileSync(targetPath, "utf-8");
-    targetData = JSON.parse(targetContent);
-  }
-  const merged = deepMerge(targetData, sourceData);
-  const mergedContent = `${JSON.stringify(merged, null, "	")}
-`;
-  if (mergedContent === targetContent) {
-    console.log(chalk14.green("settings.local.json already has ralph enabled"));
-    return;
-  }
-  console.log(chalk14.yellow("\nChanges to settings.local.json:"));
-  console.log();
-  printDiff(targetContent, mergedContent);
-  const confirm = await promptConfirm("Apply these changes?");
-  if (!confirm) {
-    console.log("Skipped");
-    return;
-  }
-  fs4.writeFileSync(targetPath, mergedContent);
-  console.log(`Updated ${targetPath}`);
-}
-
 // src/commands/verify/init.ts
-import chalk25 from "chalk";
+import chalk24 from "chalk";
 
 // src/shared/promptMultiselect.ts
-import chalk15 from "chalk";
+import chalk14 from "chalk";
 import enquirer3 from "enquirer";
 async function promptMultiselect(message, options) {
   const { selected } = await enquirer3.prompt({
@@ -1075,7 +1017,7 @@ async function promptMultiselect(message, options) {
     message,
     choices: options.map((opt) => ({
       name: opt.value,
-      message: `${opt.name} - ${chalk15.dim(opt.description)}`
+      message: `${opt.name} - ${chalk14.dim(opt.description)}`
     })),
     // @ts-expect-error - enquirer types don't include symbols but it's supported
     symbols: {
@@ -1089,23 +1031,23 @@ async function promptMultiselect(message, options) {
 }
 
 // src/shared/readPackageJson.ts
-import * as fs5 from "fs";
-import * as path3 from "path";
-import chalk16 from "chalk";
+import * as fs4 from "fs";
+import * as path2 from "path";
+import chalk15 from "chalk";
 function findPackageJson() {
-  const packageJsonPath = path3.join(process.cwd(), "package.json");
-  if (fs5.existsSync(packageJsonPath)) {
+  const packageJsonPath = path2.join(process.cwd(), "package.json");
+  if (fs4.existsSync(packageJsonPath)) {
     return packageJsonPath;
   }
   return null;
 }
 function readPackageJson(filePath) {
-  return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
 }
 function requirePackageJson() {
   const packageJsonPath = findPackageJson();
   if (!packageJsonPath) {
-    console.error(chalk16.red("No package.json found in current directory"));
+    console.error(chalk15.red("No package.json found in current directory"));
     process.exit(1);
   }
   const pkg = readPackageJson(packageJsonPath);
@@ -1114,9 +1056,9 @@ function requirePackageJson() {
 function findPackageJsonWithVerifyScripts(startDir) {
   let currentDir = startDir;
   while (true) {
-    const packageJsonPath = path3.join(currentDir, "package.json");
-    if (fs5.existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = path2.join(currentDir, "package.json");
+    if (fs4.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
       const scripts = packageJson.scripts || {};
       const verifyScripts = Object.keys(scripts).filter(
         (name) => name.startsWith("verify:")
@@ -1125,7 +1067,7 @@ function findPackageJsonWithVerifyScripts(startDir) {
         return { packageJsonPath, verifyScripts };
       }
     }
-    const parentDir = path3.dirname(currentDir);
+    const parentDir = path2.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -1143,15 +1085,15 @@ var expectedScripts = {
 };
 
 // src/commands/verify/setup/setupBuild.ts
-import chalk18 from "chalk";
+import chalk17 from "chalk";
 
 // src/commands/verify/installPackage.ts
 import { execSync as execSync7 } from "child_process";
-import * as fs6 from "fs";
-import * as path4 from "path";
-import chalk17 from "chalk";
+import * as fs5 from "fs";
+import * as path3 from "path";
+import chalk16 from "chalk";
 function writePackageJson(filePath, pkg) {
-  fs6.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
+  fs5.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
 `);
 }
 function addScript(pkg, name, command) {
@@ -1164,36 +1106,36 @@ function addScript(pkg, name, command) {
   };
 }
 function installPackage(name, cwd) {
-  console.log(chalk17.dim(`Installing ${name}...`));
+  console.log(chalk16.dim(`Installing ${name}...`));
   try {
     execSync7(`npm install -D ${name}`, { stdio: "inherit", cwd });
     return true;
   } catch {
-    console.error(chalk17.red(`Failed to install ${name}`));
+    console.error(chalk16.red(`Failed to install ${name}`));
     return false;
   }
 }
 function addToKnipIgnoreBinaries(cwd, binary) {
-  const knipJsonPath = path4.join(cwd, "knip.json");
+  const knipJsonPath = path3.join(cwd, "knip.json");
   try {
     let knipConfig;
-    if (fs6.existsSync(knipJsonPath)) {
-      knipConfig = JSON.parse(fs6.readFileSync(knipJsonPath, "utf-8"));
+    if (fs5.existsSync(knipJsonPath)) {
+      knipConfig = JSON.parse(fs5.readFileSync(knipJsonPath, "utf-8"));
     } else {
       knipConfig = { $schema: "https://unpkg.com/knip@5/schema.json" };
     }
     const ignoreBinaries = knipConfig.ignoreBinaries ?? [];
     if (!ignoreBinaries.includes(binary)) {
       knipConfig.ignoreBinaries = [...ignoreBinaries, binary];
-      fs6.writeFileSync(
+      fs5.writeFileSync(
         knipJsonPath,
         `${JSON.stringify(knipConfig, null, "	")}
 `
       );
-      console.log(chalk17.dim(`Added '${binary}' to knip.json ignoreBinaries`));
+      console.log(chalk16.dim(`Added '${binary}' to knip.json ignoreBinaries`));
     }
   } catch {
-    console.log(chalk17.yellow("Warning: Could not update knip.json"));
+    console.log(chalk16.yellow("Warning: Could not update knip.json"));
   }
 }
 function setupVerifyScript(packageJsonPath, scriptName, command) {
@@ -1205,7 +1147,7 @@ function setupVerifyScript(packageJsonPath, scriptName, command) {
 
 // src/commands/verify/setup/setupBuild.ts
 async function setupBuild(packageJsonPath, hasVite, hasTypescript) {
-  console.log(chalk18.blue("\nSetting up build verification..."));
+  console.log(chalk17.blue("\nSetting up build verification..."));
   let command;
   if (hasVite && hasTypescript) {
     command = "tsc -b && vite build --logLevel error";
@@ -1214,17 +1156,17 @@ async function setupBuild(packageJsonPath, hasVite, hasTypescript) {
   } else {
     command = "tsc --noEmit";
   }
-  console.log(chalk18.dim(`Using: ${command}`));
+  console.log(chalk17.dim(`Using: ${command}`));
   const pkg = readPackageJson(packageJsonPath);
   writePackageJson(packageJsonPath, addScript(pkg, "verify:build", command));
 }
 
 // src/commands/verify/setup/setupDuplicateCode.ts
-import * as path5 from "path";
-import chalk19 from "chalk";
+import * as path4 from "path";
+import chalk18 from "chalk";
 async function setupDuplicateCode(packageJsonPath) {
-  console.log(chalk19.blue("\nSetting up jscpd..."));
-  const cwd = path5.dirname(packageJsonPath);
+  console.log(chalk18.blue("\nSetting up jscpd..."));
+  const cwd = path4.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   const hasJscpd = !!pkg.dependencies?.jscpd || !!pkg.devDependencies?.jscpd;
   if (!hasJscpd && !installPackage("jscpd", cwd)) {
@@ -1238,11 +1180,11 @@ async function setupDuplicateCode(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupHardcodedColors.ts
-import * as path6 from "path";
-import chalk20 from "chalk";
+import * as path5 from "path";
+import chalk19 from "chalk";
 async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
-  console.log(chalk20.blue("\nSetting up hardcoded colors check..."));
-  const cwd = path6.dirname(packageJsonPath);
+  console.log(chalk19.blue("\nSetting up hardcoded colors check..."));
+  const cwd = path5.dirname(packageJsonPath);
   if (!hasOpenColor) {
     installPackage("open-color", cwd);
   }
@@ -1255,11 +1197,11 @@ async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
 }
 
 // src/commands/verify/setup/setupKnip.ts
-import * as path7 from "path";
-import chalk21 from "chalk";
+import * as path6 from "path";
+import chalk20 from "chalk";
 async function setupKnip(packageJsonPath) {
-  console.log(chalk21.blue("\nSetting up knip..."));
-  const cwd = path7.dirname(packageJsonPath);
+  console.log(chalk20.blue("\nSetting up knip..."));
+  const cwd = path6.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.knip && !installPackage("knip", cwd)) {
     return;
@@ -1272,19 +1214,19 @@ async function setupKnip(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupLint.ts
-import * as path8 from "path";
-import chalk23 from "chalk";
+import * as path7 from "path";
+import chalk22 from "chalk";
 
 // src/commands/lint/init.ts
 import { execSync as execSync9 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname7, join as join7 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import chalk22 from "chalk";
+import { existsSync as existsSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname6, join as join6 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk21 from "chalk";
 
 // src/shared/removeEslint.ts
 import { execSync as execSync8 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
 function removeEslint(options = {}) {
   const removedFromPackageJson = removeEslintFromPackageJson(options);
   const removedConfigFiles = removeEslintConfigFiles();
@@ -1297,10 +1239,10 @@ function removeEslint(options = {}) {
 }
 function removeEslintFromPackageJson(options) {
   const packageJsonPath = "package.json";
-  if (!existsSync7(packageJsonPath)) {
+  if (!existsSync6(packageJsonPath)) {
     return false;
   }
-  const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
   let modified = false;
   if (packageJson.dependencies) {
     for (const key of Object.keys(packageJson.dependencies)) {
@@ -1328,7 +1270,7 @@ function removeEslintFromPackageJson(options) {
     }
   }
   if (modified) {
-    writeFileSync6(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+    writeFileSync5(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `);
     console.log("Removed eslint references from package.json");
   }
@@ -1349,7 +1291,7 @@ function removeEslintConfigFiles() {
   ];
   let removed = false;
   for (const configFile of eslintConfigFiles) {
-    if (existsSync7(configFile)) {
+    if (existsSync6(configFile)) {
       unlinkSync(configFile);
       console.log(`Removed ${configFile}`);
       removed = true;
@@ -1359,21 +1301,21 @@ function removeEslintConfigFiles() {
 }
 
 // src/commands/lint/init.ts
-var __dirname4 = dirname7(fileURLToPath3(import.meta.url));
+var __dirname3 = dirname6(fileURLToPath2(import.meta.url));
 async function init2() {
   removeEslint();
   const biomeConfigPath = "biome.json";
-  if (!existsSync8(biomeConfigPath)) {
+  if (!existsSync7(biomeConfigPath)) {
     console.log("Initializing Biome...");
     execSync9("npx @biomejs/biome init", { stdio: "inherit" });
   }
-  if (!existsSync8(biomeConfigPath)) {
+  if (!existsSync7(biomeConfigPath)) {
     console.log("No biome.json found, skipping linter config");
     return;
   }
-  const linterConfigPath = join7(__dirname4, "commands/lint/biome.linter.json");
-  const linterConfig = JSON.parse(readFileSync9(linterConfigPath, "utf-8"));
-  const biomeConfig = JSON.parse(readFileSync9(biomeConfigPath, "utf-8"));
+  const linterConfigPath = join6(__dirname3, "commands/lint/biome.linter.json");
+  const linterConfig = JSON.parse(readFileSync8(linterConfigPath, "utf-8"));
+  const biomeConfig = JSON.parse(readFileSync8(biomeConfigPath, "utf-8"));
   const oldContent = `${JSON.stringify(biomeConfig, null, 2)}
 `;
   biomeConfig.linter = linterConfig.linter;
@@ -1386,22 +1328,22 @@ async function init2() {
     console.log("biome.json already has the correct linter config");
     return;
   }
-  console.log(chalk22.yellow("\n\u26A0\uFE0F  biome.json will be updated:"));
+  console.log(chalk21.yellow("\n\u26A0\uFE0F  biome.json will be updated:"));
   console.log();
   printDiff(oldContent, newContent);
-  const confirm = await promptConfirm(chalk22.red("Update biome.json?"));
+  const confirm = await promptConfirm(chalk21.red("Update biome.json?"));
   if (!confirm) {
     console.log("Skipped biome.json update");
     return;
   }
-  writeFileSync7(biomeConfigPath, newContent);
+  writeFileSync6(biomeConfigPath, newContent);
   console.log("Updated biome.json with linter config");
 }
 
 // src/commands/verify/setup/setupLint.ts
 async function setupLint(packageJsonPath) {
-  console.log(chalk23.blue("\nSetting up biome..."));
-  const cwd = path8.dirname(packageJsonPath);
+  console.log(chalk22.blue("\nSetting up biome..."));
+  const cwd = path7.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.["@biomejs/biome"]) {
     if (!installPackage("@biomejs/biome", cwd)) {
@@ -1417,11 +1359,11 @@ async function setupLint(packageJsonPath) {
 }
 
 // src/commands/verify/setup/setupTest.ts
-import * as path9 from "path";
-import chalk24 from "chalk";
+import * as path8 from "path";
+import chalk23 from "chalk";
 async function setupTest(packageJsonPath) {
-  console.log(chalk24.blue("\nSetting up vitest..."));
-  const cwd = path9.dirname(packageJsonPath);
+  console.log(chalk23.blue("\nSetting up vitest..."));
+  const cwd = path8.dirname(packageJsonPath);
   const pkg = readPackageJson(packageJsonPath);
   if (!pkg.devDependencies?.vitest && !installPackage("vitest", cwd)) {
     return;
@@ -1563,16 +1505,16 @@ async function init3() {
   const setup = detectExistingSetup(pkg);
   const availableOptions = getAvailableOptions(setup);
   if (availableOptions.length === 0) {
-    console.log(chalk25.green("All verify scripts are already configured!"));
+    console.log(chalk24.green("All verify scripts are already configured!"));
     return;
   }
-  console.log(chalk25.bold("Available verify scripts to add:\n"));
+  console.log(chalk24.bold("Available verify scripts to add:\n"));
   const selected = await promptMultiselect(
     "Select verify scripts to add:",
     availableOptions
   );
   if (selected.length === 0) {
-    console.log(chalk25.yellow("No scripts selected"));
+    console.log(chalk24.yellow("No scripts selected"));
     return;
   }
   for (const choice of selected) {
@@ -1597,43 +1539,43 @@ async function init3() {
         break;
     }
   }
-  console.log(chalk25.green(`
+  console.log(chalk24.green(`
 Added ${selected.length} verify script(s):`));
   for (const choice of selected) {
-    console.log(chalk25.green(`  - verify:${choice}`));
+    console.log(chalk24.green(`  - verify:${choice}`));
   }
-  console.log(chalk25.dim("\nRun 'assist verify' to run all verify scripts"));
+  console.log(chalk24.dim("\nRun 'assist verify' to run all verify scripts"));
 }
 
 // src/commands/vscode/init.ts
-import * as fs8 from "fs";
-import * as path11 from "path";
-import chalk27 from "chalk";
-
-// src/commands/vscode/createLaunchJson.ts
 import * as fs7 from "fs";
 import * as path10 from "path";
 import chalk26 from "chalk";
+
+// src/commands/vscode/createLaunchJson.ts
+import * as fs6 from "fs";
+import * as path9 from "path";
+import chalk25 from "chalk";
 function ensureVscodeFolder() {
-  const vscodeDir = path10.join(process.cwd(), ".vscode");
-  if (!fs7.existsSync(vscodeDir)) {
-    fs7.mkdirSync(vscodeDir);
-    console.log(chalk26.dim("Created .vscode folder"));
+  const vscodeDir = path9.join(process.cwd(), ".vscode");
+  if (!fs6.existsSync(vscodeDir)) {
+    fs6.mkdirSync(vscodeDir);
+    console.log(chalk25.dim("Created .vscode folder"));
   }
 }
 function removeVscodeFromGitignore() {
-  const gitignorePath = path10.join(process.cwd(), ".gitignore");
-  if (!fs7.existsSync(gitignorePath)) {
+  const gitignorePath = path9.join(process.cwd(), ".gitignore");
+  if (!fs6.existsSync(gitignorePath)) {
     return;
   }
-  const content = fs7.readFileSync(gitignorePath, "utf-8");
+  const content = fs6.readFileSync(gitignorePath, "utf-8");
   const lines = content.split("\n");
   const filteredLines = lines.filter(
     (line) => !line.trim().toLowerCase().includes(".vscode")
   );
   if (filteredLines.length !== lines.length) {
-    fs7.writeFileSync(gitignorePath, filteredLines.join("\n"));
-    console.log(chalk26.dim("Removed .vscode references from .gitignore"));
+    fs6.writeFileSync(gitignorePath, filteredLines.join("\n"));
+    console.log(chalk25.dim("Removed .vscode references from .gitignore"));
   }
 }
 function createLaunchJson() {
@@ -1648,10 +1590,10 @@ function createLaunchJson() {
       }
     ]
   };
-  const launchPath = path10.join(process.cwd(), ".vscode", "launch.json");
-  fs7.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
+  const launchPath = path9.join(process.cwd(), ".vscode", "launch.json");
+  fs6.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
 `);
-  console.log(chalk26.green("Created .vscode/launch.json"));
+  console.log(chalk25.green("Created .vscode/launch.json"));
 }
 function createSettingsJson() {
   const settings = {
@@ -1661,31 +1603,31 @@ function createSettingsJson() {
       "source.organizeImports.biome": "explicit"
     }
   };
-  const settingsPath = path10.join(process.cwd(), ".vscode", "settings.json");
-  fs7.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
+  const settingsPath = path9.join(process.cwd(), ".vscode", "settings.json");
+  fs6.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
 `);
-  console.log(chalk26.green("Created .vscode/settings.json"));
+  console.log(chalk25.green("Created .vscode/settings.json"));
 }
 function createExtensionsJson() {
   const extensions = {
     recommendations: ["biomejs.biome"]
   };
-  const extensionsPath = path10.join(process.cwd(), ".vscode", "extensions.json");
-  fs7.writeFileSync(
+  const extensionsPath = path9.join(process.cwd(), ".vscode", "extensions.json");
+  fs6.writeFileSync(
     extensionsPath,
     `${JSON.stringify(extensions, null, "	")}
 `
   );
-  console.log(chalk26.green("Created .vscode/extensions.json"));
+  console.log(chalk25.green("Created .vscode/extensions.json"));
 }
 
 // src/commands/vscode/init.ts
 function detectExistingSetup2(pkg) {
-  const vscodeDir = path11.join(process.cwd(), ".vscode");
+  const vscodeDir = path10.join(process.cwd(), ".vscode");
   return {
-    hasVscodeFolder: fs8.existsSync(vscodeDir),
-    hasLaunchJson: fs8.existsSync(path11.join(vscodeDir, "launch.json")),
-    hasSettingsJson: fs8.existsSync(path11.join(vscodeDir, "settings.json")),
+    hasVscodeFolder: fs7.existsSync(vscodeDir),
+    hasLaunchJson: fs7.existsSync(path10.join(vscodeDir, "launch.json")),
+    hasSettingsJson: fs7.existsSync(path10.join(vscodeDir, "settings.json")),
     hasVite: !!pkg.devDependencies?.vite || !!pkg.dependencies?.vite
   };
 }
@@ -1708,16 +1650,16 @@ async function init4() {
     });
   }
   if (availableOptions.length === 0) {
-    console.log(chalk27.green("VS Code configuration already exists!"));
+    console.log(chalk26.green("VS Code configuration already exists!"));
     return;
   }
-  console.log(chalk27.bold("Available VS Code configurations to add:\n"));
+  console.log(chalk26.bold("Available VS Code configurations to add:\n"));
   const selected = await promptMultiselect(
     "Select configurations to add:",
     availableOptions
   );
   if (selected.length === 0) {
-    console.log(chalk27.yellow("No configurations selected"));
+    console.log(chalk26.yellow("No configurations selected"));
     return;
   }
   removeVscodeFromGitignore();
@@ -1734,7 +1676,7 @@ async function init4() {
     }
   }
   console.log(
-    chalk27.green(`
+    chalk26.green(`
 Added ${selected.length} VS Code configuration(s)`)
   );
 }
@@ -1746,23 +1688,23 @@ async function init5() {
 }
 
 // src/commands/lint/runFileNameCheck.ts
-import fs10 from "fs";
-import path13 from "path";
-import chalk28 from "chalk";
-
-// src/shared/findSourceFiles.ts
 import fs9 from "fs";
 import path12 from "path";
+import chalk27 from "chalk";
+
+// src/shared/findSourceFiles.ts
+import fs8 from "fs";
+import path11 from "path";
 var EXTENSIONS = [".ts", ".tsx"];
 function findSourceFiles(dir, options = {}) {
   const { includeTests = true } = options;
   const results = [];
-  if (!fs9.existsSync(dir)) {
+  if (!fs8.existsSync(dir)) {
     return results;
   }
-  const entries = fs9.readdirSync(dir, { withFileTypes: true });
+  const entries = fs8.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path11.join(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "node_modules") {
       results.push(...findSourceFiles(fullPath, options));
     } else if (entry.isFile() && EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
@@ -1786,10 +1728,10 @@ function checkFileNames() {
   const sourceFiles = findSourceFiles("src");
   const violations = [];
   for (const filePath of sourceFiles) {
-    const fileName = path13.basename(filePath);
+    const fileName = path12.basename(filePath);
     const nameWithoutExt = fileName.replace(/\.(ts|tsx)$/, "");
     if (/^[A-Z]/.test(nameWithoutExt)) {
-      const content = fs10.readFileSync(filePath, "utf-8");
+      const content = fs9.readFileSync(filePath, "utf-8");
       if (!hasClassOrComponent(content)) {
         violations.push({ filePath, fileName });
       }
@@ -1800,16 +1742,16 @@ function checkFileNames() {
 function runFileNameCheck() {
   const violations = checkFileNames();
   if (violations.length > 0) {
-    console.error(chalk28.red("\nFile name check failed:\n"));
+    console.error(chalk27.red("\nFile name check failed:\n"));
     console.error(
-      chalk28.red(
+      chalk27.red(
         "  Files without classes or React components should not start with a capital letter.\n"
       )
     );
     for (const violation of violations) {
-      console.error(chalk28.red(`  ${violation.filePath}`));
+      console.error(chalk27.red(`  ${violation.filePath}`));
       console.error(
-        chalk28.gray(
+        chalk27.gray(
           `    Rename to: ${violation.fileName.charAt(0).toLowerCase()}${violation.fileName.slice(1)}
 `
         )
@@ -1826,20 +1768,20 @@ function runFileNameCheck() {
 }
 
 // src/commands/lint/runImportExtensionCheck.ts
-import fs11 from "fs";
+import fs10 from "fs";
 
 // src/commands/lint/shared.ts
-import chalk29 from "chalk";
+import chalk28 from "chalk";
 function reportViolations(violations, checkName, errorMessage, successMessage) {
   if (violations.length > 0) {
-    console.error(chalk29.red(`
+    console.error(chalk28.red(`
 ${checkName} failed:
 `));
-    console.error(chalk29.red(`  ${errorMessage}
+    console.error(chalk28.red(`  ${errorMessage}
 `));
     for (const violation of violations) {
-      console.error(chalk29.red(`  ${violation.filePath}:${violation.line}`));
-      console.error(chalk29.gray(`    ${violation.content}
+      console.error(chalk28.red(`  ${violation.filePath}:${violation.line}`));
+      console.error(chalk28.gray(`    ${violation.content}
 `));
     }
     return false;
@@ -1852,7 +1794,7 @@ ${checkName} failed:
 
 // src/commands/lint/runImportExtensionCheck.ts
 function checkForImportExtensions(filePath) {
-  const content = fs11.readFileSync(filePath, "utf-8");
+  const content = fs10.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const violations = [];
   const importExtensionPattern = /from\s+["']\..*\.(js|ts)["']/;
@@ -1886,9 +1828,9 @@ function runImportExtensionCheck() {
 }
 
 // src/commands/lint/runStaticImportCheck.ts
-import fs12 from "fs";
+import fs11 from "fs";
 function checkForDynamicImports(filePath) {
-  const content = fs12.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const violations = [];
   const requirePattern = /\brequire\s*\(/;
@@ -1934,7 +1876,7 @@ function lint() {
 
 // src/commands/new/newProject.ts
 import { execSync as execSync10 } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
 async function newProject() {
   console.log("Initializing Vite with react-ts template...");
   execSync10("npm create vite@latest . -- --template react-ts", {
@@ -1947,11 +1889,11 @@ async function newProject() {
 }
 function addViteBaseConfig() {
   const viteConfigPath = "vite.config.ts";
-  if (!existsSync11(viteConfigPath)) {
+  if (!existsSync10(viteConfigPath)) {
     console.log("No vite.config.ts found, skipping base config");
     return;
   }
-  const content = readFileSync11(viteConfigPath, "utf-8");
+  const content = readFileSync10(viteConfigPath, "utf-8");
   if (content.includes("base:")) {
     console.log("vite.config.ts already has base config");
     return;
@@ -1961,7 +1903,7 @@ function addViteBaseConfig() {
     'defineConfig({\n	base: "./",'
   );
   if (updated !== content) {
-    writeFileSync9(viteConfigPath, updated);
+    writeFileSync8(viteConfigPath, updated);
     console.log('Added base: "./" to vite.config.ts');
   }
 }
@@ -2002,19 +1944,19 @@ function detectPlatform() {
 
 // src/commands/notify/showWindowsNotificationFromWsl.ts
 import { spawn } from "child_process";
-import fs13 from "fs";
+import fs12 from "fs";
 import { createRequire } from "module";
-import path14 from "path";
+import path13 from "path";
 var require2 = createRequire(import.meta.url);
 function getSnoreToastPath() {
-  const notifierPath = path14.dirname(require2.resolve("node-notifier"));
-  return path14.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
+  const notifierPath = path13.dirname(require2.resolve("node-notifier"));
+  return path13.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
 }
 function showWindowsNotificationFromWsl(options) {
   const { title, message, sound } = options;
   const snoreToastPath = getSnoreToastPath();
   try {
-    fs13.chmodSync(snoreToastPath, 493);
+    fs12.chmodSync(snoreToastPath, 493);
   } catch {
   }
   const args = ["-t", title, "-m", message];
@@ -2084,11 +2026,17 @@ async function notify() {
   console.log(`Notification sent: ${notification_type} for ${projectName}`);
 }
 
-// src/commands/prs.ts
+// src/commands/prs/comments.ts
+import { execSync as execSync12 } from "child_process";
+import chalk29 from "chalk";
+
+// src/lib/isClaudeCode.ts
+function isClaudeCode() {
+  return process.env.CLAUDECODE !== void 0;
+}
+
+// src/commands/prs/shared.ts
 import { execSync as execSync11 } from "child_process";
-import chalk30 from "chalk";
-import enquirer4 from "enquirer";
-var PAGE_SIZE = 10;
 function isGhNotInstalled(error) {
   if (error instanceof Error) {
     const msg = error.message.toLowerCase();
@@ -2108,10 +2056,104 @@ function getRepoInfo() {
   );
   return { org: repoInfo.owner.login, repo: repoInfo.name };
 }
+
+// src/commands/prs/comments.ts
+function formatForHuman(comment) {
+  if (comment.type === "review") {
+    const stateColor = comment.state === "APPROVED" ? chalk29.green : comment.state === "CHANGES_REQUESTED" ? chalk29.red : chalk29.yellow;
+    return [
+      `${chalk29.cyan("Review")} by ${chalk29.bold(comment.user)} ${stateColor(`[${comment.state}]`)}`,
+      comment.body,
+      ""
+    ].join("\n");
+  }
+  const location = comment.line ? `:${comment.line}` : "";
+  return [
+    `${chalk29.cyan("Line comment")} by ${chalk29.bold(comment.user)} on ${chalk29.dim(`${comment.path}${location}`)}`,
+    chalk29.dim(comment.diff_hunk.split("\n").slice(-3).join("\n")),
+    comment.body,
+    ""
+  ].join("\n");
+}
+function printComments(comments2) {
+  if (comments2.length === 0) {
+    console.log("No comments found.");
+    return;
+  }
+  if (isClaudeCode()) {
+    for (const comment of comments2) {
+      console.log(JSON.stringify(comment));
+    }
+  } else {
+    for (const comment of comments2) {
+      console.log(formatForHuman(comment));
+    }
+  }
+}
+async function comments(prNumber) {
+  try {
+    const { org, repo } = getRepoInfo();
+    const allComments = [];
+    const reviewResult = execSync12(
+      `gh api repos/${org}/${repo}/pulls/${prNumber}/reviews`,
+      { encoding: "utf-8" }
+    );
+    if (reviewResult.trim()) {
+      const reviews = JSON.parse(reviewResult);
+      for (const review of reviews) {
+        if (review.body) {
+          allComments.push({
+            type: "review",
+            id: review.id,
+            user: review.user.login,
+            state: review.state,
+            body: review.body
+          });
+        }
+      }
+    }
+    const lineResult = execSync12(
+      `gh api repos/${org}/${repo}/pulls/${prNumber}/comments`,
+      { encoding: "utf-8" }
+    );
+    if (lineResult.trim()) {
+      const lineComments = JSON.parse(lineResult);
+      for (const comment of lineComments) {
+        allComments.push({
+          type: "line",
+          id: comment.id,
+          user: comment.user.login,
+          path: comment.path,
+          line: comment.line,
+          body: comment.body,
+          diff_hunk: comment.diff_hunk
+        });
+      }
+    }
+    return allComments;
+  } catch (error) {
+    if (isGhNotInstalled(error)) {
+      console.error("Error: GitHub CLI (gh) is not installed.");
+      console.error("Install it from https://cli.github.com/");
+      return [];
+    }
+    if (isNotFound(error)) {
+      console.error("Error: Pull request not found.");
+      return [];
+    }
+    throw error;
+  }
+}
+
+// src/commands/prs/prs.ts
+import { execSync as execSync13 } from "child_process";
+import chalk30 from "chalk";
+import enquirer4 from "enquirer";
+var PAGE_SIZE = 10;
 async function prs(options) {
   const state = options.open ? "open" : options.closed ? "closed" : "all";
   try {
-    const result = execSync11(
+    const result = execSync13(
       `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100`,
       { encoding: "utf-8" }
     );
@@ -2192,78 +2234,24 @@ Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
     }
   }
 }
-async function comments(prNumber) {
-  try {
-    const { org, repo } = getRepoInfo();
-    const allComments = [];
-    const reviewResult = execSync11(
-      `gh api repos/${org}/${repo}/pulls/${prNumber}/reviews`,
-      { encoding: "utf-8" }
-    );
-    if (reviewResult.trim()) {
-      const reviews = JSON.parse(reviewResult);
-      for (const review of reviews) {
-        if (review.body) {
-          allComments.push({
-            type: "review",
-            id: review.id,
-            user: review.user.login,
-            state: review.state,
-            body: review.body
-          });
-        }
-      }
-    }
-    const lineResult = execSync11(
-      `gh api repos/${org}/${repo}/pulls/${prNumber}/comments`,
-      { encoding: "utf-8" }
-    );
-    if (lineResult.trim()) {
-      const lineComments = JSON.parse(lineResult);
-      for (const comment of lineComments) {
-        allComments.push({
-          type: "line",
-          id: comment.id,
-          user: comment.user.login,
-          path: comment.path,
-          line: comment.line,
-          body: comment.body,
-          diff_hunk: comment.diff_hunk
-        });
-      }
-    }
-    return allComments;
-  } catch (error) {
-    if (isGhNotInstalled(error)) {
-      console.error("Error: GitHub CLI (gh) is not installed.");
-      console.error("Install it from https://cli.github.com/");
-      return [];
-    }
-    if (isNotFound(error)) {
-      console.error("Error: Pull request not found.");
-      return [];
-    }
-    throw error;
-  }
-}
 
 // src/commands/refactor/check.ts
 import { spawn as spawn2 } from "child_process";
-import * as path15 from "path";
+import * as path14 from "path";
 
 // src/commands/refactor/getViolations.ts
-import { execSync as execSync12 } from "child_process";
-import fs15 from "fs";
+import { execSync as execSync14 } from "child_process";
+import fs14 from "fs";
 import { minimatch as minimatch2 } from "minimatch";
 
 // src/commands/refactor/getIgnoredFiles.ts
-import fs14 from "fs";
+import fs13 from "fs";
 var REFACTOR_YML_PATH = "refactor.yml";
 function parseRefactorYml() {
-  if (!fs14.existsSync(REFACTOR_YML_PATH)) {
+  if (!fs13.existsSync(REFACTOR_YML_PATH)) {
     return [];
   }
-  const content = fs14.readFileSync(REFACTOR_YML_PATH, "utf-8");
+  const content = fs13.readFileSync(REFACTOR_YML_PATH, "utf-8");
   const entries = [];
   const lines = content.split("\n");
   let currentEntry = {};
@@ -2348,7 +2336,7 @@ Refactor check failed:
 
 // src/commands/refactor/getViolations.ts
 function countLines(filePath) {
-  const content = fs15.readFileSync(filePath, "utf-8");
+  const content = fs14.readFileSync(filePath, "utf-8");
   return content.split("\n").length;
 }
 function getGitFiles(options) {
@@ -2357,7 +2345,7 @@ function getGitFiles(options) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options.staged || options.modified) {
-    const staged = execSync12("git diff --cached --name-only", {
+    const staged = execSync14("git diff --cached --name-only", {
       encoding: "utf-8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -2365,7 +2353,7 @@ function getGitFiles(options) {
     }
   }
   if (options.unstaged || options.modified) {
-    const unstaged = execSync12("git diff --name-only", { encoding: "utf-8" });
+    const unstaged = execSync14("git diff --name-only", { encoding: "utf-8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -2400,7 +2388,7 @@ async function runVerifyQuietly() {
     return true;
   }
   const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path15.dirname(packageJsonPath);
+  const packageDir = path14.dirname(packageJsonPath);
   const results = await Promise.all(
     verifyScripts.map(
       (script) => new Promise(
@@ -2453,25 +2441,25 @@ async function check(pattern2, options) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs16 from "fs";
+import fs15 from "fs";
 import chalk32 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
-  if (!fs16.existsSync(file)) {
+  if (!fs15.existsSync(file)) {
     console.error(chalk32.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs16.readFileSync(file, "utf-8");
+  const content = fs15.readFileSync(file, "utf-8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs16.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs16.readFileSync(REFACTOR_YML_PATH2, "utf-8");
-    fs16.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs15.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs15.readFileSync(REFACTOR_YML_PATH2, "utf-8");
+    fs15.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs16.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs15.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
     chalk32.green(
@@ -2565,22 +2553,22 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs18 from "fs";
+import * as fs17 from "fs";
 import * as os from "os";
-import * as path17 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import * as path16 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/sync/syncSettings.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 import chalk33 from "chalk";
 async function syncSettings(claudeDir, targetBase) {
-  const source = path16.join(claudeDir, "settings.json");
-  const target = path16.join(targetBase, "settings.json");
-  const sourceContent = fs17.readFileSync(source, "utf-8");
+  const source = path15.join(claudeDir, "settings.json");
+  const target = path15.join(targetBase, "settings.json");
+  const sourceContent = fs16.readFileSync(source, "utf-8");
   const normalizedSource = JSON.stringify(JSON.parse(sourceContent), null, 2);
-  if (fs17.existsSync(target)) {
-    const targetContent = fs17.readFileSync(target, "utf-8");
+  if (fs16.existsSync(target)) {
+    const targetContent = fs16.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(JSON.parse(targetContent), null, 2);
     if (normalizedSource !== normalizedTarget) {
       console.log(
@@ -2598,37 +2586,37 @@ async function syncSettings(claudeDir, targetBase) {
       }
     }
   }
-  fs17.copyFileSync(source, target);
+  fs16.copyFileSync(source, target);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
-var __filename2 = fileURLToPath4(import.meta.url);
-var __dirname5 = path17.dirname(__filename2);
+var __filename2 = fileURLToPath3(import.meta.url);
+var __dirname4 = path16.dirname(__filename2);
 async function sync() {
-  const claudeDir = path17.join(__dirname5, "..", "claude");
-  const targetBase = path17.join(os.homedir(), ".claude");
+  const claudeDir = path16.join(__dirname4, "..", "claude");
+  const targetBase = path16.join(os.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path17.join(claudeDir, "commands");
-  const targetDir = path17.join(targetBase, "commands");
-  fs18.mkdirSync(targetDir, { recursive: true });
-  const files = fs18.readdirSync(sourceDir);
+  const sourceDir = path16.join(claudeDir, "commands");
+  const targetDir = path16.join(targetBase, "commands");
+  fs17.mkdirSync(targetDir, { recursive: true });
+  const files = fs17.readdirSync(sourceDir);
   for (const file of files) {
-    fs18.copyFileSync(path17.join(sourceDir, file), path17.join(targetDir, file));
+    fs17.copyFileSync(path16.join(sourceDir, file), path16.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
 }
 
 // src/commands/verify/hardcodedColors.ts
-import { execSync as execSync13 } from "child_process";
+import { execSync as execSync15 } from "child_process";
 var pattern = "0x[0-9a-fA-F]{6}|#[0-9a-fA-F]{3,6}";
 function hardcodedColors() {
   try {
-    const output = execSync13(`grep -rEnH '${pattern}' src/`, {
+    const output = execSync15(`grep -rEnH '${pattern}' src/`, {
       encoding: "utf-8"
     });
     const lines = output.trim().split("\n");
@@ -2658,7 +2646,7 @@ Total: ${lines.length} hardcoded color(s)`);
 
 // src/commands/verify/run.ts
 import { spawn as spawn4 } from "child_process";
-import * as path18 from "path";
+import * as path17 from "path";
 function formatDuration(ms) {
   if (ms < 1e3) {
     return `${ms}ms`;
@@ -2688,7 +2676,7 @@ async function run2(options = {}) {
     return;
   }
   const { packageJsonPath, verifyScripts } = result;
-  const packageDir = path18.dirname(packageJsonPath);
+  const packageDir = path17.dirname(packageJsonPath);
   console.log(`Running ${verifyScripts.length} verify script(s) in parallel:`);
   for (const script of verifyScripts) {
     console.log(`  - ${script}`);
@@ -2738,15 +2726,11 @@ program.command("init").description("Initialize VS Code and verify configuration
 program.command("commit <message>").description("Create a git commit with validation").action(commit);
 program.command("update").description("Update claude-code to the latest version").action(() => {
   console.log("Updating claude-code...");
-  execSync14("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
+  execSync16("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
 });
 var prsCommand = program.command("prs").description("Pull request utilities").option("--open", "List only open pull requests").option("--closed", "List only closed pull requests").action(prs);
 prsCommand.command("comments <pr-number>").description("List all comments on a pull request").action((prNumber) => {
-  comments(Number.parseInt(prNumber, 10)).then((comments2) => {
-    for (const comment of comments2) {
-      console.log(JSON.stringify(comment));
-    }
-  });
+  comments(Number.parseInt(prNumber, 10)).then(printComments);
 });
 var runCommand = program.command("run").description("Run a configured command from assist.yml").argument("<name>", "Name of the configured command").argument("[args...]", "Arguments to pass to the command").allowUnknownOption().action((name, args) => {
   run(name, args);
@@ -2779,7 +2763,6 @@ vscodeCommand.command("init").description("Add VS Code configuration files").act
 var deployCommand = program.command("deploy").description("Netlify deployment utilities");
 deployCommand.command("init").description("Initialize Netlify project and configure deployment").action(init);
 deployCommand.command("redirect").description("Add trailing slash redirect script to index.html").action(redirect);
-program.command("enable-ralph").description("Enable ralph-wiggum plugin for spacetraders").action(enableRalph);
 program.command("status-line").description("Format Claude Code status line from JSON stdin").action(statusLine);
 program.command("notify").description(
   "Show notification from Claude Code hook (reads JSON from stdin)"

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.21.2",
+	"version": "0.22.1",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {

package/dist/commands/enable-ralph/index.ts

@@ -1,78 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import chalk from "chalk";
-import { promptConfirm } from "../../shared/promptConfirm";
-import { printDiff } from "../../utils/printDiff";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-function deepMerge(
-	target: Record<string, unknown>,
-	source: Record<string, unknown>,
-): Record<string, unknown> {
-	const result = { ...target };
-	for (const key of Object.keys(source)) {
-		const sourceVal = source[key];
-		const targetVal = result[key];
-		if (
-			sourceVal &&
-			typeof sourceVal === "object" &&
-			!Array.isArray(sourceVal) &&
-			targetVal &&
-			typeof targetVal === "object" &&
-			!Array.isArray(targetVal)
-		) {
-			result[key] = deepMerge(
-				targetVal as Record<string, unknown>,
-				sourceVal as Record<string, unknown>,
-			);
-		} else {
-			result[key] = sourceVal;
-		}
-	}
-	return result;
-}
-
-export async function enableRalph(): Promise<void> {
-	const sourcePath = path.join(
-		__dirname,
-		"commands/enable-ralph/settings.local.json",
-	);
-	const targetPath = path.join(process.cwd(), ".claude/settings.local.json");
-	const sourceData = JSON.parse(fs.readFileSync(sourcePath, "utf-8"));
-
-	const targetDir = path.dirname(targetPath);
-	if (!fs.existsSync(targetDir)) {
-		fs.mkdirSync(targetDir, { recursive: true });
-	}
-
-	let targetData: Record<string, unknown> = {};
-	let targetContent = "{}";
-	if (fs.existsSync(targetPath)) {
-		targetContent = fs.readFileSync(targetPath, "utf-8");
-		targetData = JSON.parse(targetContent);
-	}
-
-	const merged = deepMerge(targetData, sourceData);
-	const mergedContent = `${JSON.stringify(merged, null, "\t")}\n`;
-
-	if (mergedContent === targetContent) {
-		console.log(chalk.green("settings.local.json already has ralph enabled"));
-		return;
-	}
-
-	console.log(chalk.yellow("\nChanges to settings.local.json:"));
-	console.log();
-	printDiff(targetContent, mergedContent);
-
-	const confirm = await promptConfirm("Apply these changes?");
-
-	if (!confirm) {
-		console.log("Skipped");
-		return;
-	}
-
-	fs.writeFileSync(targetPath, mergedContent);
-	console.log(`Updated ${targetPath}`);
-}

package/dist/commands/enable-ralph/settings.local.json

@@ -1,8 +0,0 @@
-{
-	"permissions": {
-		"allow": ["Bash"]
-	},
-	"enabledPlugins": {
-		"ralph-wiggum@claude-plugins-official": true
-	}
-}