@staff0rd/assist 0.22.0 → 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

@@ -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];
@@ -2086,7 +2028,7 @@ async function notify() {
 
 // src/commands/prs/comments.ts
 import { execSync as execSync12 } from "child_process";
-import chalk30 from "chalk";
+import chalk29 from "chalk";
 
 // src/lib/isClaudeCode.ts
 function isClaudeCode() {
@@ -2118,17 +2060,17 @@ function getRepoInfo() {
 // src/commands/prs/comments.ts
 function formatForHuman(comment) {
   if (comment.type === "review") {
-    const stateColor = comment.state === "APPROVED" ? chalk30.green : comment.state === "CHANGES_REQUESTED" ? chalk30.red : chalk30.yellow;
+    const stateColor = comment.state === "APPROVED" ? chalk29.green : comment.state === "CHANGES_REQUESTED" ? chalk29.red : chalk29.yellow;
     return [
-      `${chalk30.cyan("Review")} by ${chalk30.bold(comment.user)} ${stateColor(`[${comment.state}]`)}`,
+      `${chalk29.cyan("Review")} by ${chalk29.bold(comment.user)} ${stateColor(`[${comment.state}]`)}`,
       comment.body,
       ""
     ].join("\n");
   }
   const location = comment.line ? `:${comment.line}` : "";
   return [
-    `${chalk30.cyan("Line comment")} by ${chalk30.bold(comment.user)} on ${chalk30.dim(`${comment.path}${location}`)}`,
-    chalk30.dim(comment.diff_hunk.split("\n").slice(-3).join("\n")),
+    `${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");
@@ -2205,7 +2147,7 @@ async function comments(prNumber) {
 
 // src/commands/prs/prs.ts
 import { execSync as execSync13 } from "child_process";
-import chalk31 from "chalk";
+import chalk30 from "chalk";
 import enquirer4 from "enquirer";
 var PAGE_SIZE = 10;
 async function prs(options) {
@@ -2237,12 +2179,12 @@ async function displayPaginated(pullRequests) {
   let currentPage = 0;
   const getStatus = (pr) => {
     if (pr.state === "MERGED" && pr.mergedAt) {
-      return { label: chalk31.magenta("merged"), date: pr.mergedAt };
+      return { label: chalk30.magenta("merged"), date: pr.mergedAt };
     }
     if (pr.state === "CLOSED" && pr.closedAt) {
-      return { label: chalk31.red("closed"), date: pr.closedAt };
+      return { label: chalk30.red("closed"), date: pr.closedAt };
     }
-    return { label: chalk31.green("opened"), date: pr.createdAt };
+    return { label: chalk30.green("opened"), date: pr.createdAt };
   };
   const displayPage = (page) => {
     const start = page * PAGE_SIZE;
@@ -2258,9 +2200,9 @@ Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
       const formattedDate = new Date(status.date).toISOString().split("T")[0];
       const fileCount = pr.changedFiles.toLocaleString();
       console.log(
-        `${chalk31.cyan(`#${pr.number}`)} ${pr.title} ${chalk31.dim(`(${pr.author.login},`)} ${status.label} ${chalk31.dim(`${formattedDate})`)}`
+        `${chalk30.cyan(`#${pr.number}`)} ${pr.title} ${chalk30.dim(`(${pr.author.login},`)} ${status.label} ${chalk30.dim(`${formattedDate})`)}`
       );
-      console.log(chalk31.dim(`  ${fileCount} files | ${pr.url}`));
+      console.log(chalk30.dim(`  ${fileCount} files | ${pr.url}`));
       console.log();
     }
   };
@@ -2295,21 +2237,21 @@ Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
 
 // 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 execSync14 } from "child_process";
-import fs15 from "fs";
+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 = {};
@@ -2338,7 +2280,7 @@ function getIgnoredFiles() {
 }
 
 // src/commands/refactor/logViolations.ts
-import chalk32 from "chalk";
+import chalk31 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -2347,43 +2289,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk32.red(`
+  console.error(chalk31.red(`
 Refactor check failed:
 `));
-  console.error(chalk32.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk31.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk32.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk31.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk32.yellow(
+    chalk31.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk32.gray(`    assist refactor ignore <file>
+  console.error(chalk31.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk32.cyan(`
+    console.error(chalk31.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk32.cyan(
+      chalk31.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk32.cyan(
+      chalk31.cyan(
         `  1. Keep related logic together: If the extracted code is tightly coupled to the
      original file's domain, create a new folder containing both the original and extracted files.
 `
       )
     );
     console.error(
-      chalk32.cyan(
+      chalk31.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -2394,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) {
@@ -2446,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(
@@ -2499,28 +2441,28 @@ async function check(pattern2, options) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs16 from "fs";
-import chalk33 from "chalk";
+import fs15 from "fs";
+import chalk32 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
-  if (!fs16.existsSync(file)) {
-    console.error(chalk33.red(`Error: File does not exist: ${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(
-    chalk33.green(
+    chalk32.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -2611,31 +2553,31 @@ 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 chalk34 from "chalk";
+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(
-        chalk34.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
+        chalk33.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk34.red("Overwrite existing settings.json?"),
+        chalk33.red("Overwrite existing settings.json?"),
         false
       );
       if (!confirm) {
@@ -2644,26 +2586,26 @@ 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`);
@@ -2704,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`;
@@ -2734,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}`);
@@ -2821,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.22.0",
+	"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
-	}
-}