@staff0rd/assist 0.10.1

package/dist/index.js

@@ -0,0 +1,2003 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { execSync as execSync12 } from "child_process";
+import { Command } from "commander";
+
+// src/commands/commit.ts
+import { execSync } from "child_process";
+var MAX_MESSAGE_LENGTH = 50;
+function commit(message) {
+  if (message.toLowerCase().includes("claude")) {
+    console.error("Error: Commit message must not reference Claude");
+    process.exit(1);
+  }
+  if (message.length > MAX_MESSAGE_LENGTH) {
+    console.error(
+      `Error: Commit message must be ${MAX_MESSAGE_LENGTH} characters or less (current: ${message.length})`
+    );
+    process.exit(1);
+  }
+  try {
+    execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+      stdio: "inherit"
+    });
+    process.exit(0);
+  } catch (_error) {
+    process.exit(1);
+  }
+}
+
+// src/commands/deploy/init.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import chalk2 from "chalk";
+import enquirer from "enquirer";
+
+// src/utils/printDiff.ts
+import chalk from "chalk";
+import * as diff from "diff";
+function normalizeJson(content) {
+  try {
+    return JSON.stringify(JSON.parse(content), null, 2);
+  } catch {
+    return content;
+  }
+}
+function printDiff(oldContent, newContent) {
+  const changes = diff.diffLines(
+    normalizeJson(oldContent),
+    normalizeJson(newContent)
+  );
+  for (const change of changes) {
+    const lines = change.value.replace(/\n$/, "").split("\n");
+    for (const line of lines) {
+      if (change.added) {
+        console.log(chalk.green(`+ ${line}`));
+      } else if (change.removed) {
+        console.log(chalk.red(`- ${line}`));
+      } else {
+        console.log(chalk.dim(`  ${line}`));
+      }
+    }
+  }
+}
+
+// src/commands/deploy/init.ts
+var WORKFLOW_PATH = ".github/workflows/build.yml";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+function getExistingSiteId() {
+  if (!existsSync(WORKFLOW_PATH)) {
+    return null;
+  }
+  const content = readFileSync(WORKFLOW_PATH, "utf-8");
+  const match = content.match(/-s\s+([a-f0-9-]{36})/);
+  return match ? match[1] : null;
+}
+function getTemplateContent(siteId) {
+  const templatePath = join(__dirname2, "commands/deploy/build.yml");
+  const template = readFileSync(templatePath, "utf-8");
+  return template.replace("{{NETLIFY_SITE_ID}}", siteId);
+}
+async function updateWorkflow(siteId) {
+  const newContent = getTemplateContent(siteId);
+  const workflowDir = ".github/workflows";
+  if (!existsSync(workflowDir)) {
+    mkdirSync(workflowDir, { recursive: true });
+  }
+  if (existsSync(WORKFLOW_PATH)) {
+    const oldContent = readFileSync(WORKFLOW_PATH, "utf-8");
+    if (oldContent === newContent) {
+      console.log(chalk2.green("build.yml is already up to date"));
+      return;
+    }
+    console.log(chalk2.yellow("\nbuild.yml will be updated:"));
+    console.log();
+    printDiff(oldContent, newContent);
+    const { confirm } = await enquirer.prompt({
+      type: "confirm",
+      name: "confirm",
+      message: chalk2.red("Update build.yml?"),
+      initial: true
+    });
+    if (!confirm) {
+      console.log("Skipped build.yml update");
+      return;
+    }
+  }
+  writeFileSync(WORKFLOW_PATH, newContent);
+  console.log(chalk2.green(`
+Created ${WORKFLOW_PATH}`));
+}
+async function init() {
+  console.log(chalk2.bold("Initializing Netlify deployment...\n"));
+  const existingSiteId = getExistingSiteId();
+  if (existingSiteId) {
+    console.log(chalk2.dim(`Using existing site ID: ${existingSiteId}
+`));
+    await updateWorkflow(existingSiteId);
+    return;
+  }
+  console.log("Creating Netlify site...\n");
+  execSync2("netlify sites:create --disable-linking", {
+    stdio: "inherit"
+  });
+  const { siteId } = await enquirer.prompt({
+    type: "input",
+    name: "siteId",
+    message: "Enter the Site ID from above:",
+    validate: (value) => /^[a-f0-9-]+$/i.test(value) || "Invalid site ID format"
+  });
+  await updateWorkflow(siteId);
+  console.log(chalk2.bold("\nDeployment initialized successfully!"));
+  console.log(
+    chalk2.yellow("\nTo complete setup, create a personal access token at:")
+  );
+  console.log(
+    chalk2.cyan(
+      "https://app.netlify.com/user/applications#personal-access-tokens"
+    )
+  );
+  console.log(
+    chalk2.yellow(
+      "\nThen add it as NETLIFY_AUTH_TOKEN in your GitHub repository secrets."
+    )
+  );
+}
+
+// src/commands/devlog/list.ts
+import { execSync as execSync4 } from "child_process";
+import { basename as basename2 } from "path";
+import chalk4 from "chalk";
+
+// src/commands/devlog/shared.ts
+import { execSync as execSync3 } from "child_process";
+import chalk3 from "chalk";
+
+// src/shared/loadConfig.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join2 } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function getConfigPath() {
+  const claudeConfigPath = join2(process.cwd(), ".claude", "assist.yml");
+  if (existsSync2(claudeConfigPath)) {
+    return claudeConfigPath;
+  }
+  return join2(process.cwd(), "assist.yml");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync2(configPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync2(configPath, "utf-8");
+    return parseYaml(content) || {};
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  writeFileSync2(configPath, stringifyYaml(config, { lineWidth: 0 }));
+}
+function getRepoName() {
+  const config = loadConfig();
+  if (config.devlog?.name) {
+    return config.devlog.name;
+  }
+  const packageJsonPath = join2(process.cwd(), "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const content = readFileSync2(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.name) {
+        return pkg.name;
+      }
+    } catch {
+    }
+  }
+  return basename(process.cwd());
+}
+
+// src/commands/devlog/loadDevlogEntries.ts
+import { readdirSync, readFileSync as readFileSync3 } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+var DEVLOG_DIR = join3(homedir(), "git/blog/src/content/devlog");
+function loadDevlogEntries(repoName) {
+  const entries = /* @__PURE__ */ new Map();
+  try {
+    const files = readdirSync(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const content = readFileSync3(join3(DEVLOG_DIR, file), "utf-8");
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (frontmatterMatch) {
+        const frontmatter = frontmatterMatch[1];
+        const dateMatch = frontmatter.match(/date:\s*"?(\d{4}-\d{2}-\d{2})"?/);
+        const versionMatch = frontmatter.match(/version:\s*(.+)/);
+        const titleMatch = frontmatter.match(/title:\s*(.+)/);
+        const tagsMatch = frontmatter.match(/tags:\s*\[([^\]]*)\]/);
+        if (dateMatch && versionMatch && titleMatch && tagsMatch) {
+          const tags = tagsMatch[1].split(",").map((t) => t.trim());
+          const firstTag = tags[0];
+          if (firstTag !== repoName) {
+            continue;
+          }
+          const date = dateMatch[1];
+          const version2 = versionMatch[1].trim();
+          const title = titleMatch[1].trim();
+          const existing = entries.get(date) || [];
+          existing.push({ version: version2, title, filename: file });
+          entries.set(date, existing);
+        }
+      }
+    }
+  } catch {
+  }
+  return entries;
+}
+
+// src/commands/devlog/shared.ts
+function getCommitFiles(hash) {
+  try {
+    const output = execSync3(`git show --name-only --format="" ${hash}`, {
+      encoding: "utf-8"
+    });
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function shouldIgnoreCommit(files, ignorePaths) {
+  if (ignorePaths.length === 0 || files.length === 0) {
+    return false;
+  }
+  return files.every(
+    (file) => ignorePaths.some((ignorePath) => file.startsWith(ignorePath))
+  );
+}
+function printCommitsWithFiles(commits, ignore2, verbose) {
+  for (const commit2 of commits) {
+    console.log(`  ${chalk3.yellow(commit2.hash)} ${commit2.message}`);
+    if (verbose) {
+      const visibleFiles = commit2.files.filter(
+        (file) => !ignore2.some((p) => file.startsWith(p))
+      );
+      for (const file of visibleFiles) {
+        console.log(`    ${chalk3.dim(file)}`);
+      }
+    }
+  }
+}
+
+// src/commands/devlog/list.ts
+function list(options) {
+  const config = loadConfig();
+  const days = options.days ?? 30;
+  const ignore2 = options.ignore ?? config.devlog?.ignore ?? [];
+  const skipDays = new Set(config.devlog?.skip?.days ?? []);
+  const repoName = basename2(process.cwd());
+  const devlogEntries = loadDevlogEntries(repoName);
+  const reverseFlag = options.reverse ? "--reverse " : "";
+  const limitFlag = options.reverse ? "" : "-n 500 ";
+  const output = execSync4(
+    `git log ${reverseFlag}${limitFlag}--pretty=format:'%ad|%h|%s' --date=short`,
+    { encoding: "utf-8" }
+  );
+  const lines = output.trim().split("\n");
+  const commits = [];
+  for (const line of lines) {
+    const [date, hash, ...messageParts] = line.split("|");
+    const message = messageParts.join("|");
+    const files = getCommitFiles(hash);
+    if (!shouldIgnoreCommit(files, ignore2)) {
+      commits.push({ date, hash, message, files });
+    }
+  }
+  const commitsByDate = /* @__PURE__ */ new Map();
+  for (const commit2 of commits) {
+    const existing = commitsByDate.get(commit2.date) || [];
+    existing.push(commit2);
+    commitsByDate.set(commit2.date, existing);
+  }
+  let dateCount = 0;
+  let isFirst = true;
+  for (const [date, dateCommits] of commitsByDate) {
+    if (options.since) {
+      if (date < options.since) {
+        break;
+      }
+    } else if (dateCount >= days) {
+      break;
+    }
+    dateCount++;
+    if (!isFirst) {
+      console.log();
+    }
+    isFirst = false;
+    const entries = devlogEntries.get(date);
+    if (skipDays.has(date)) {
+      console.log(`${chalk4.bold.blue(date)} ${chalk4.dim("skipped")}`);
+    } else if (entries && entries.length > 0) {
+      const entryInfo = entries.map((e) => `${chalk4.green(e.version)} ${e.title}`).join(" | ");
+      console.log(`${chalk4.bold.blue(date)} ${entryInfo}`);
+    } else {
+      console.log(`${chalk4.bold.blue(date)} ${chalk4.red("\u26A0 devlog missing")}`);
+    }
+    printCommitsWithFiles(dateCommits, ignore2, options.verbose ?? false);
+  }
+}
+
+// src/commands/devlog/next.ts
+import { execSync as execSync5 } from "child_process";
+import chalk5 from "chalk";
+
+// src/commands/devlog/getLastVersionInfo.ts
+import semver from "semver";
+function getLastVersionInfo(repoName) {
+  const entries = loadDevlogEntries(repoName);
+  if (entries.size === 0) {
+    return null;
+  }
+  const dates = Array.from(entries.keys()).sort().reverse();
+  const lastDate = dates[0];
+  if (!lastDate) {
+    return null;
+  }
+  const lastEntries = entries.get(lastDate);
+  const lastVersion = lastEntries?.[0]?.version;
+  if (!lastVersion) {
+    return null;
+  }
+  return { date: lastDate, version: lastVersion };
+}
+function bumpVersion(version2, type) {
+  const cleaned = semver.clean(version2) ?? semver.coerce(version2)?.version;
+  if (!cleaned) {
+    return version2;
+  }
+  const bumped = semver.inc(cleaned, type);
+  if (!bumped) {
+    return version2;
+  }
+  if (type === "minor") {
+    const parsed = semver.parse(bumped);
+    return parsed ? `v${parsed.major}.${parsed.minor}` : `v${bumped}`;
+  }
+  return `v${bumped}`;
+}
+
+// src/commands/devlog/next.ts
+function next(options) {
+  const config = loadConfig();
+  const ignore2 = options.ignore ?? config.devlog?.ignore ?? [];
+  const skipDays = new Set(config.devlog?.skip?.days ?? []);
+  const repoName = getRepoName();
+  const lastInfo = getLastVersionInfo(repoName);
+  const lastDate = lastInfo?.date ?? null;
+  const patchVersion = lastInfo ? bumpVersion(lastInfo.version, "patch") : null;
+  const minorVersion = lastInfo ? bumpVersion(lastInfo.version, "minor") : null;
+  const output = execSync5(
+    "git log --pretty=format:'%ad|%h|%s' --date=short -n 500",
+    { encoding: "utf-8" }
+  );
+  const lines = output.trim().split("\n");
+  const commitsByDate = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const [date, hash, ...messageParts] = line.split("|");
+    const message = messageParts.join("|");
+    if (lastDate && date <= lastDate) {
+      continue;
+    }
+    const files = getCommitFiles(hash);
+    if (!shouldIgnoreCommit(files, ignore2)) {
+      const existing = commitsByDate.get(date) || [];
+      existing.push({ date, hash, message, files });
+      commitsByDate.set(date, existing);
+    }
+  }
+  const dates = Array.from(commitsByDate.keys()).filter((d) => !skipDays.has(d)).sort();
+  const targetDate = dates[0];
+  if (!targetDate) {
+    if (lastInfo) {
+      console.log(chalk5.dim("No commits after last versioned entry"));
+    } else {
+      console.log(chalk5.dim("No commits found"));
+    }
+    return;
+  }
+  const commits = commitsByDate.get(targetDate) ?? [];
+  console.log(`${chalk5.bold("name:")} ${repoName}`);
+  if (patchVersion && minorVersion) {
+    console.log(
+      `${chalk5.bold("version:")} ${patchVersion} (patch) or ${minorVersion} (minor)`
+    );
+  } else {
+    console.log(`${chalk5.bold("version:")} v0.1 (initial)`);
+  }
+  console.log(`${chalk5.bold.blue(targetDate)}`);
+  printCommitsWithFiles(commits, ignore2, options.verbose ?? false);
+}
+
+// src/commands/devlog/skip.ts
+import chalk6 from "chalk";
+function skip(date) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    console.log(chalk6.red("Invalid date format. Use YYYY-MM-DD"));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const skipDays = config.devlog?.skip?.days ?? [];
+  if (skipDays.includes(date)) {
+    console.log(chalk6.yellow(`${date} is already in skip list`));
+    return;
+  }
+  skipDays.push(date);
+  skipDays.sort();
+  config.devlog = {
+    ...config.devlog,
+    skip: {
+      ...config.devlog?.skip,
+      days: skipDays
+    }
+  };
+  saveConfig(config);
+  console.log(chalk6.green(`Added ${date} to skip list`));
+}
+
+// src/commands/devlog/version.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+import chalk7 from "chalk";
+import semver2 from "semver";
+function getLatestVersion(repoName) {
+  try {
+    const files = readdirSync2(DEVLOG_DIR).filter((f) => f.endsWith(".md")).sort().reverse();
+    for (const file of files) {
+      const content = readFileSync4(join4(DEVLOG_DIR, file), "utf-8");
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (frontmatterMatch) {
+        const frontmatter = frontmatterMatch[1];
+        const versionMatch = frontmatter.match(/version:\s*(.+)/);
+        const tagsMatch = frontmatter.match(/tags:\s*\[([^\]]*)\]/);
+        if (versionMatch && tagsMatch) {
+          const tags = tagsMatch[1].split(",").map((t) => t.trim());
+          const firstTag = tags[0];
+          if (firstTag === repoName) {
+            return versionMatch[1].trim();
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function bumpPatchVersion(version2) {
+  const cleaned = semver2.clean(version2) ?? semver2.coerce(version2)?.version;
+  if (!cleaned) {
+    return version2;
+  }
+  const bumped = semver2.inc(cleaned, "patch");
+  return bumped ? `v${bumped}` : version2;
+}
+function version() {
+  const name = getRepoName();
+  const lastVersion = getLatestVersion(name);
+  const nextVersion = lastVersion ? bumpPatchVersion(lastVersion) : null;
+  console.log(`${chalk7.bold("name:")} ${name}`);
+  console.log(`${chalk7.bold("last:")} ${lastVersion ?? chalk7.dim("none")}`);
+  console.log(`${chalk7.bold("next:")} ${nextVersion ?? chalk7.dim("none")}`);
+}
+
+// src/commands/enable-ralph/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk8 from "chalk";
+import enquirer2 from "enquirer";
+var __dirname3 = path.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 = path.join(
+    __dirname3,
+    "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 = {};
+  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, "	") + "\n";
+  if (mergedContent === targetContent) {
+    console.log(chalk8.green("settings.local.json already has ralph enabled"));
+    return;
+  }
+  console.log(chalk8.yellow("\nChanges to settings.local.json:"));
+  console.log();
+  printDiff(targetContent, mergedContent);
+  const { confirm } = await enquirer2.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: "Apply these changes?",
+    initial: true
+  });
+  if (!confirm) {
+    console.log("Skipped");
+    return;
+  }
+  fs.writeFileSync(targetPath, mergedContent);
+  console.log(`Updated ${targetPath}`);
+}
+
+// src/commands/verify/init.ts
+import chalk19 from "chalk";
+
+// src/shared/promptMultiselect.ts
+import chalk9 from "chalk";
+import enquirer3 from "enquirer";
+async function promptMultiselect(message, options) {
+  const { selected } = await enquirer3.prompt({
+    type: "multiselect",
+    name: "selected",
+    message,
+    choices: options.map((opt) => ({
+      name: opt.value,
+      message: `${opt.name} - ${chalk9.dim(opt.description)}`
+    }))
+  });
+  return selected;
+}
+
+// src/shared/readPackageJson.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import chalk10 from "chalk";
+function findPackageJson() {
+  const packageJsonPath = path2.join(process.cwd(), "package.json");
+  if (fs2.existsSync(packageJsonPath)) {
+    return packageJsonPath;
+  }
+  return null;
+}
+function readPackageJson(filePath) {
+  return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+}
+function requirePackageJson() {
+  const packageJsonPath = findPackageJson();
+  if (!packageJsonPath) {
+    console.error(chalk10.red("No package.json found in current directory"));
+    process.exit(1);
+  }
+  const pkg = readPackageJson(packageJsonPath);
+  return { packageJsonPath, pkg };
+}
+function findPackageJsonWithVerifyScripts(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const packageJsonPath = path2.join(currentDir, "package.json");
+    if (fs2.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+      const scripts = packageJson.scripts || {};
+      const verifyScripts = Object.keys(scripts).filter(
+        (name) => name.startsWith("verify:")
+      );
+      if (verifyScripts.length > 0) {
+        return { packageJsonPath, verifyScripts };
+      }
+    }
+    const parentDir = path2.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+// src/commands/verify/setup/EXPECTED_SCRIPTS.ts
+var EXPECTED_SCRIPTS = {
+  "verify:knip": "knip --no-progress",
+  "verify:lint": "biome check --write .",
+  "verify:duplicate-code": "jscpd --format 'typescript,tsx' --exitCode 1 --ignore '**/*.test.*' -r consoleFull src",
+  "verify:test": "vitest run --reporter=dot --silent",
+  "verify:hardcoded-colors": "assist verify hardcoded-colors"
+};
+
+// src/commands/verify/setup/setupBuild.ts
+import chalk12 from "chalk";
+
+// src/commands/verify/installPackage.ts
+import { execSync as execSync6 } from "child_process";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import chalk11 from "chalk";
+function writePackageJson(filePath, pkg) {
+  fs3.writeFileSync(filePath, `${JSON.stringify(pkg, null, 2)}
+`);
+}
+function addScript(pkg, name, command) {
+  return {
+    ...pkg,
+    scripts: {
+      ...pkg.scripts,
+      [name]: command
+    }
+  };
+}
+function installPackage(name, cwd) {
+  console.log(chalk11.dim(`Installing ${name}...`));
+  try {
+    execSync6(`npm install -D ${name}`, { stdio: "inherit", cwd });
+    return true;
+  } catch {
+    console.error(chalk11.red(`Failed to install ${name}`));
+    return false;
+  }
+}
+function addToKnipIgnoreBinaries(cwd, binary) {
+  const knipJsonPath = path3.join(cwd, "knip.json");
+  try {
+    let knipConfig;
+    if (fs3.existsSync(knipJsonPath)) {
+      knipConfig = JSON.parse(fs3.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];
+      fs3.writeFileSync(
+        knipJsonPath,
+        `${JSON.stringify(knipConfig, null, "	")}
+`
+      );
+      console.log(chalk11.dim(`Added '${binary}' to knip.json ignoreBinaries`));
+    }
+  } catch {
+    console.log(chalk11.yellow("Warning: Could not update knip.json"));
+  }
+}
+function setupVerifyScript(packageJsonPath, scriptName, command) {
+  writePackageJson(
+    packageJsonPath,
+    addScript(readPackageJson(packageJsonPath), scriptName, command)
+  );
+}
+
+// src/commands/verify/setup/setupBuild.ts
+async function setupBuild(packageJsonPath, hasVite, hasTypescript) {
+  console.log(chalk12.blue("\nSetting up build verification..."));
+  let command;
+  if (hasVite && hasTypescript) {
+    command = "tsc -b && vite build --logLevel error";
+  } else if (hasVite) {
+    command = "vite build --logLevel error";
+  } else {
+    command = "tsc --noEmit";
+  }
+  console.log(chalk12.dim(`Using: ${command}`));
+  const pkg = readPackageJson(packageJsonPath);
+  writePackageJson(packageJsonPath, addScript(pkg, "verify:build", command));
+}
+
+// src/commands/verify/setup/setupDuplicateCode.ts
+import * as path4 from "path";
+import chalk13 from "chalk";
+async function setupDuplicateCode(packageJsonPath) {
+  console.log(chalk13.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)) {
+    return;
+  }
+  setupVerifyScript(
+    packageJsonPath,
+    "verify:duplicate-code",
+    EXPECTED_SCRIPTS["verify:duplicate-code"]
+  );
+}
+
+// src/commands/verify/setup/setupHardcodedColors.ts
+import * as path5 from "path";
+import chalk14 from "chalk";
+async function setupHardcodedColors(packageJsonPath, hasOpenColor) {
+  console.log(chalk14.blue("\nSetting up hardcoded colors check..."));
+  const cwd = path5.dirname(packageJsonPath);
+  if (!hasOpenColor) {
+    installPackage("open-color", cwd);
+  }
+  addToKnipIgnoreBinaries(cwd, "assist");
+  setupVerifyScript(
+    packageJsonPath,
+    "verify:hardcoded-colors",
+    EXPECTED_SCRIPTS["verify:hardcoded-colors"]
+  );
+}
+
+// src/commands/verify/setup/setupKnip.ts
+import * as path6 from "path";
+import chalk15 from "chalk";
+async function setupKnip(packageJsonPath) {
+  console.log(chalk15.blue("\nSetting up knip..."));
+  const cwd = path6.dirname(packageJsonPath);
+  const pkg = readPackageJson(packageJsonPath);
+  if (!pkg.devDependencies?.knip && !installPackage("knip", cwd)) {
+    return;
+  }
+  setupVerifyScript(
+    packageJsonPath,
+    "verify:knip",
+    EXPECTED_SCRIPTS["verify:knip"]
+  );
+}
+
+// src/commands/verify/setup/setupLint.ts
+import * as path7 from "path";
+import chalk17 from "chalk";
+
+// src/commands/lint/init.ts
+import { execSync as execSync7 } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, join as join8 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import chalk16 from "chalk";
+import enquirer4 from "enquirer";
+var __dirname4 = dirname7(fileURLToPath3(import.meta.url));
+async function init2() {
+  const biomeConfigPath = "biome.json";
+  if (!existsSync6(biomeConfigPath)) {
+    console.log("Initializing Biome...");
+    execSync7("npx @biomejs/biome init", { stdio: "inherit" });
+  }
+  if (!existsSync6(biomeConfigPath)) {
+    console.log("No biome.json found, skipping linter config");
+    return;
+  }
+  const linterConfigPath = join8(__dirname4, "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;
+  if (linterConfig.overrides) {
+    biomeConfig.overrides = linterConfig.overrides;
+  }
+  const newContent = `${JSON.stringify(biomeConfig, null, 2)}
+`;
+  if (oldContent === newContent) {
+    console.log("biome.json already has the correct linter config");
+    return;
+  }
+  console.log(chalk16.yellow("\n\u26A0\uFE0F  biome.json will be updated:"));
+  console.log();
+  printDiff(oldContent, newContent);
+  const { confirm } = await enquirer4.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: chalk16.red("Update biome.json?"),
+    initial: true
+  });
+  if (!confirm) {
+    console.log("Skipped biome.json update");
+    return;
+  }
+  writeFileSync5(biomeConfigPath, newContent);
+  console.log("Updated biome.json with linter config");
+}
+
+// src/commands/verify/setup/setupLint.ts
+async function setupLint(packageJsonPath) {
+  console.log(chalk17.blue("\nSetting up biome..."));
+  const cwd = path7.dirname(packageJsonPath);
+  const pkg = readPackageJson(packageJsonPath);
+  if (!pkg.devDependencies?.["@biomejs/biome"]) {
+    if (!installPackage("@biomejs/biome", cwd)) {
+      return;
+    }
+  }
+  await init2();
+  setupVerifyScript(
+    packageJsonPath,
+    "verify:lint",
+    EXPECTED_SCRIPTS["verify:lint"]
+  );
+}
+
+// src/commands/verify/setup/setupTest.ts
+import * as path8 from "path";
+import chalk18 from "chalk";
+async function setupTest(packageJsonPath) {
+  console.log(chalk18.blue("\nSetting up vitest..."));
+  const cwd = path8.dirname(packageJsonPath);
+  const pkg = readPackageJson(packageJsonPath);
+  if (!pkg.devDependencies?.vitest && !installPackage("vitest", cwd)) {
+    return;
+  }
+  setupVerifyScript(
+    packageJsonPath,
+    "verify:test",
+    EXPECTED_SCRIPTS["verify:test"]
+  );
+}
+
+// src/commands/verify/needsSetup.ts
+function needsSetup(status) {
+  return !status.hasScript || !status.hasPackage || status.isOutdated;
+}
+function getStatusLabel(status) {
+  if (status.isOutdated) return " (outdated)";
+  if (!status.hasScript) return "";
+  if (!status.hasPackage) return " (package missing)";
+  return "";
+}
+
+// src/commands/verify/detectExistingSetup.ts
+function isScriptOutdated(pkg, scriptName, expectedCommand) {
+  const currentScript = pkg.scripts?.[scriptName];
+  if (!currentScript || !expectedCommand) return false;
+  return currentScript !== expectedCommand;
+}
+function detectExistingSetup(pkg) {
+  return {
+    knip: {
+      hasPackage: !!pkg.devDependencies?.knip,
+      hasScript: !!pkg.scripts?.["verify:knip"],
+      isOutdated: isScriptOutdated(
+        pkg,
+        "verify:knip",
+        EXPECTED_SCRIPTS["verify:knip"]
+      )
+    },
+    biome: {
+      hasPackage: !!pkg.devDependencies?.["@biomejs/biome"],
+      hasScript: !!pkg.scripts?.["verify:lint"],
+      isOutdated: isScriptOutdated(
+        pkg,
+        "verify:lint",
+        EXPECTED_SCRIPTS["verify:lint"]
+      )
+    },
+    jscpd: {
+      hasPackage: !!pkg.dependencies?.jscpd || !!pkg.devDependencies?.jscpd,
+      hasScript: !!pkg.scripts?.["verify:duplicate-code"],
+      isOutdated: isScriptOutdated(
+        pkg,
+        "verify:duplicate-code",
+        EXPECTED_SCRIPTS["verify:duplicate-code"]
+      )
+    },
+    test: {
+      hasPackage: !!pkg.devDependencies?.vitest,
+      hasScript: !!pkg.scripts?.["verify:test"],
+      isOutdated: isScriptOutdated(
+        pkg,
+        "verify:test",
+        EXPECTED_SCRIPTS["verify:test"]
+      )
+    },
+    hasVite: !!pkg.devDependencies?.vite || !!pkg.dependencies?.vite,
+    hasTypescript: !!pkg.devDependencies?.typescript,
+    build: {
+      hasPackage: true,
+      hasScript: !!pkg.scripts?.["verify:build"],
+      isOutdated: false
+    },
+    hardcodedColors: {
+      hasPackage: true,
+      hasScript: !!pkg.scripts?.["verify:hardcoded-colors"],
+      isOutdated: isScriptOutdated(
+        pkg,
+        "verify:hardcoded-colors",
+        EXPECTED_SCRIPTS["verify:hardcoded-colors"]
+      )
+    },
+    hasOpenColor: !!pkg.dependencies?.["open-color"] || !!pkg.devDependencies?.["open-color"]
+  };
+}
+
+// src/commands/verify/getAvailableOptions.ts
+function getAvailableOptions(setup) {
+  const options = [];
+  if (needsSetup(setup.knip)) {
+    options.push({
+      name: `knip${getStatusLabel(setup.knip)}`,
+      value: "knip",
+      description: "Dead code and unused dependency detection"
+    });
+  }
+  if (needsSetup(setup.biome)) {
+    options.push({
+      name: `lint${getStatusLabel(setup.biome)}`,
+      value: "lint",
+      description: "Code linting and formatting with Biome"
+    });
+  }
+  if (needsSetup(setup.jscpd)) {
+    options.push({
+      name: `duplicate-code${getStatusLabel(setup.jscpd)}`,
+      value: "duplicate-code",
+      description: "Duplicate code detection with jscpd"
+    });
+  }
+  if (needsSetup(setup.test) && setup.test.hasPackage) {
+    options.push({
+      name: `test${getStatusLabel(setup.test)}`,
+      value: "test",
+      description: "Run tests with vitest"
+    });
+  }
+  if (needsSetup(setup.build) && (setup.hasTypescript || setup.hasVite)) {
+    const description = setup.hasVite ? setup.hasTypescript ? "TypeScript + Vite build verification" : "Vite build verification" : "TypeScript type checking";
+    options.push({
+      name: `build${getStatusLabel(setup.build)}`,
+      value: "build",
+      description
+    });
+  }
+  if (needsSetup(setup.hardcodedColors)) {
+    options.push({
+      name: `hardcoded-colors${getStatusLabel(setup.hardcodedColors)}`,
+      value: "hardcoded-colors",
+      description: "Detect hardcoded hex colors (use open-color instead)"
+    });
+  }
+  return options;
+}
+
+// src/commands/verify/init.ts
+async function init3() {
+  const { packageJsonPath, pkg } = requirePackageJson();
+  const setup = detectExistingSetup(pkg);
+  const availableOptions = getAvailableOptions(setup);
+  if (availableOptions.length === 0) {
+    console.log(chalk19.green("All verify scripts are already configured!"));
+    return;
+  }
+  console.log(chalk19.bold("Available verify scripts to add:\n"));
+  const selected = await promptMultiselect(
+    "Select verify scripts to add:",
+    availableOptions
+  );
+  if (selected.length === 0) {
+    console.log(chalk19.yellow("No scripts selected"));
+    return;
+  }
+  for (const choice of selected) {
+    switch (choice) {
+      case "knip":
+        await setupKnip(packageJsonPath);
+        break;
+      case "lint":
+        await setupLint(packageJsonPath);
+        break;
+      case "duplicate-code":
+        await setupDuplicateCode(packageJsonPath);
+        break;
+      case "test":
+        await setupTest(packageJsonPath);
+        break;
+      case "build":
+        await setupBuild(packageJsonPath, setup.hasVite, setup.hasTypescript);
+        break;
+      case "hardcoded-colors":
+        await setupHardcodedColors(packageJsonPath, setup.hasOpenColor);
+        break;
+    }
+  }
+  console.log(chalk19.green(`
+Added ${selected.length} verify script(s):`));
+  for (const choice of selected) {
+    console.log(chalk19.green(`  - verify:${choice}`));
+  }
+  console.log(chalk19.dim("\nRun 'assist verify' to run all verify scripts"));
+}
+
+// src/commands/vscode/init.ts
+import * as fs5 from "fs";
+import * as path10 from "path";
+import chalk21 from "chalk";
+
+// src/commands/vscode/createLaunchJson.ts
+import * as fs4 from "fs";
+import * as path9 from "path";
+import chalk20 from "chalk";
+function ensureVscodeFolder() {
+  const vscodeDir = path9.join(process.cwd(), ".vscode");
+  if (!fs4.existsSync(vscodeDir)) {
+    fs4.mkdirSync(vscodeDir);
+    console.log(chalk20.dim("Created .vscode folder"));
+  }
+}
+function removeVscodeFromGitignore() {
+  const gitignorePath = path9.join(process.cwd(), ".gitignore");
+  if (!fs4.existsSync(gitignorePath)) {
+    return;
+  }
+  const content = fs4.readFileSync(gitignorePath, "utf-8");
+  const lines = content.split("\n");
+  const filteredLines = lines.filter(
+    (line) => !line.trim().toLowerCase().includes(".vscode")
+  );
+  if (filteredLines.length !== lines.length) {
+    fs4.writeFileSync(gitignorePath, filteredLines.join("\n"));
+    console.log(chalk20.dim("Removed .vscode references from .gitignore"));
+  }
+}
+function createLaunchJson() {
+  const launchConfig = {
+    version: "0.2.0",
+    configurations: [
+      {
+        name: "npm run dev",
+        type: "node-terminal",
+        request: "launch",
+        command: "npm run dev -- --open"
+      }
+    ]
+  };
+  const launchPath = path9.join(process.cwd(), ".vscode", "launch.json");
+  fs4.writeFileSync(launchPath, `${JSON.stringify(launchConfig, null, "	")}
+`);
+  console.log(chalk20.green("Created .vscode/launch.json"));
+}
+function createSettingsJson() {
+  const settings = {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true,
+    "[json]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    },
+    "[typescript]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    },
+    "[typescriptreact]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    }
+  };
+  const settingsPath = path9.join(process.cwd(), ".vscode", "settings.json");
+  fs4.writeFileSync(settingsPath, `${JSON.stringify(settings, null, "	")}
+`);
+  console.log(chalk20.green("Created .vscode/settings.json"));
+}
+function createExtensionsJson() {
+  const extensions = {
+    recommendations: ["biomejs.biome"]
+  };
+  const extensionsPath = path9.join(process.cwd(), ".vscode", "extensions.json");
+  fs4.writeFileSync(
+    extensionsPath,
+    `${JSON.stringify(extensions, null, "	")}
+`
+  );
+  console.log(chalk20.green("Created .vscode/extensions.json"));
+}
+
+// src/commands/vscode/init.ts
+function detectExistingSetup2(pkg) {
+  const vscodeDir = path10.join(process.cwd(), ".vscode");
+  return {
+    hasVscodeFolder: fs5.existsSync(vscodeDir),
+    hasLaunchJson: fs5.existsSync(path10.join(vscodeDir, "launch.json")),
+    hasSettingsJson: fs5.existsSync(path10.join(vscodeDir, "settings.json")),
+    hasVite: !!pkg.devDependencies?.vite || !!pkg.dependencies?.vite
+  };
+}
+async function init4() {
+  const { pkg } = requirePackageJson();
+  const setup = detectExistingSetup2(pkg);
+  const availableOptions = [];
+  if (!setup.hasLaunchJson && setup.hasVite) {
+    availableOptions.push({
+      name: "launch",
+      value: "launch",
+      description: "Debug configuration for Vite dev server"
+    });
+  }
+  if (!setup.hasSettingsJson) {
+    availableOptions.push({
+      name: "settings",
+      value: "settings",
+      description: "Biome formatter configuration"
+    });
+  }
+  if (availableOptions.length === 0) {
+    console.log(chalk21.green("VS Code configuration already exists!"));
+    return;
+  }
+  console.log(chalk21.bold("Available VS Code configurations to add:\n"));
+  const selected = await promptMultiselect(
+    "Select configurations to add:",
+    availableOptions
+  );
+  if (selected.length === 0) {
+    console.log(chalk21.yellow("No configurations selected"));
+    return;
+  }
+  removeVscodeFromGitignore();
+  ensureVscodeFolder();
+  for (const choice of selected) {
+    switch (choice) {
+      case "launch":
+        createLaunchJson();
+        break;
+      case "settings":
+        createSettingsJson();
+        createExtensionsJson();
+        break;
+    }
+  }
+  console.log(
+    chalk21.green(`
+Added ${selected.length} VS Code configuration(s)`)
+  );
+}
+
+// src/commands/init.ts
+async function init5() {
+  await init4();
+  await init3();
+}
+
+// src/commands/lint/runFileNameCheck.ts
+import fs7 from "fs";
+import path12 from "path";
+import chalk22 from "chalk";
+
+// src/shared/findSourceFiles.ts
+import fs6 from "fs";
+import path11 from "path";
+var EXTENSIONS = [".ts", ".tsx"];
+function findSourceFiles(dir, options = {}) {
+  const { includeTests = true } = options;
+  const results = [];
+  if (!fs6.existsSync(dir)) {
+    return results;
+  }
+  const entries = fs6.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    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))) {
+      if (!includeTests && entry.name.includes(".test.")) {
+        continue;
+      }
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// src/commands/lint/runFileNameCheck.ts
+function hasClassOrComponent(content) {
+  const classPattern = /^(export\s+)?(abstract\s+)?class\s+\w+/m;
+  const functionComponentPattern = /^(export\s+)?(default\s+)?function\s+[A-Z]\w*\s*\(/m;
+  const arrowComponentPattern = /^(export\s+)?(const|let)\s+[A-Z]\w*\s*=.*=>/m;
+  return classPattern.test(content) || functionComponentPattern.test(content) || arrowComponentPattern.test(content);
+}
+function checkFileNames() {
+  const sourceFiles = findSourceFiles("src");
+  const violations = [];
+  for (const filePath of sourceFiles) {
+    const fileName = path12.basename(filePath);
+    const nameWithoutExt = fileName.replace(/\.(ts|tsx)$/, "");
+    if (/^[A-Z]/.test(nameWithoutExt)) {
+      const content = fs7.readFileSync(filePath, "utf-8");
+      if (!hasClassOrComponent(content)) {
+        violations.push({ filePath, fileName });
+      }
+    }
+  }
+  return violations;
+}
+function runFileNameCheck() {
+  const violations = checkFileNames();
+  if (violations.length > 0) {
+    console.error(chalk22.red("\nFile name check failed:\n"));
+    console.error(
+      chalk22.red(
+        "  Files without classes or React components should not start with a capital letter.\n"
+      )
+    );
+    for (const violation of violations) {
+      console.error(chalk22.red(`  ${violation.filePath}`));
+      console.error(
+        chalk22.gray(
+          `    Rename to: ${violation.fileName.charAt(0).toLowerCase()}${violation.fileName.slice(1)}
+`
+        )
+      );
+    }
+    return false;
+  }
+  if (!process.env.CLAUDECODE) {
+    console.log(
+      "File name check passed. All PascalCase files contain classes or components."
+    );
+  }
+  return true;
+}
+
+// src/commands/lint/runStaticImportCheck.ts
+import fs8 from "fs";
+import chalk23 from "chalk";
+function checkForDynamicImports(filePath) {
+  const content = fs8.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const violations = [];
+  const requirePattern = /\brequire\s*\(/;
+  const dynamicImportPattern = /\bimport\s*\(/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (requirePattern.test(line) || dynamicImportPattern.test(line)) {
+      violations.push({
+        filePath,
+        line: i + 1,
+        content: line.trim()
+      });
+    }
+  }
+  return violations;
+}
+function checkStaticImports() {
+  const sourceFiles = findSourceFiles("src");
+  const violations = [];
+  for (const filePath of sourceFiles) {
+    violations.push(...checkForDynamicImports(filePath));
+  }
+  return violations;
+}
+function runStaticImportCheck() {
+  const violations = checkStaticImports();
+  if (violations.length > 0) {
+    console.error(chalk23.red("\nStatic import check failed:\n"));
+    console.error(
+      chalk23.red(
+        "  Dynamic imports (require() and import()) are not allowed. Use static imports instead.\n"
+      )
+    );
+    for (const violation of violations) {
+      console.error(chalk23.red(`  ${violation.filePath}:${violation.line}`));
+      console.error(chalk23.gray(`    ${violation.content}
+`));
+    }
+    return false;
+  }
+  if (!process.env.CLAUDECODE) {
+    console.log("Static import check passed. No dynamic imports found.");
+  }
+  return true;
+}
+
+// src/commands/lint/lint.ts
+function lint() {
+  const fileNamePassed = runFileNameCheck();
+  const staticImportPassed = runStaticImportCheck();
+  if (!fileNamePassed || !staticImportPassed) {
+    process.exit(1);
+  }
+}
+
+// src/commands/new/newProject.ts
+import { execSync as execSync8 } from "child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync10, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
+async function newProject() {
+  console.log("Initializing Vite with react-ts template...");
+  execSync8("npm create vite@latest . -- --template react-ts", {
+    stdio: "inherit"
+  });
+  removeEslintFromPackageJson();
+  removeEslintConfigFile();
+  addViteBaseConfig();
+  await init5();
+  await init();
+}
+function removeEslintFromPackageJson() {
+  const packageJsonPath = "package.json";
+  if (!existsSync9(packageJsonPath)) {
+    console.log("No package.json found, skipping eslint removal");
+    return;
+  }
+  const packageJson = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
+  let modified = false;
+  if (packageJson.dependencies) {
+    for (const key of Object.keys(packageJson.dependencies)) {
+      if (key.includes("eslint")) {
+        delete packageJson.dependencies[key];
+        modified = true;
+      }
+    }
+  }
+  if (packageJson.devDependencies) {
+    for (const key of Object.keys(packageJson.devDependencies)) {
+      if (key.includes("eslint")) {
+        delete packageJson.devDependencies[key];
+        modified = true;
+      }
+    }
+  }
+  if (packageJson.scripts) {
+    for (const key of Object.keys(packageJson.scripts)) {
+      if (key.includes("eslint") || key.includes("lint") || packageJson.scripts[key].includes("eslint")) {
+        delete packageJson.scripts[key];
+        modified = true;
+      }
+    }
+  }
+  if (modified) {
+    writeFileSync7(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+    console.log("Removed eslint references from package.json");
+  }
+}
+function addViteBaseConfig() {
+  const viteConfigPath = "vite.config.ts";
+  if (!existsSync9(viteConfigPath)) {
+    console.log("No vite.config.ts found, skipping base config");
+    return;
+  }
+  const content = readFileSync10(viteConfigPath, "utf-8");
+  if (content.includes("base:")) {
+    console.log("vite.config.ts already has base config");
+    return;
+  }
+  const updated = content.replace(
+    /defineConfig\(\{/,
+    'defineConfig({\n	base: "./",'
+  );
+  if (updated !== content) {
+    writeFileSync7(viteConfigPath, updated);
+    console.log('Added base: "./" to vite.config.ts');
+  }
+}
+function removeEslintConfigFile() {
+  const eslintConfigFiles = [
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs",
+    ".eslintrc",
+    ".eslintrc.js",
+    ".eslintrc.cjs",
+    ".eslintrc.json",
+    ".eslintrc.yaml",
+    ".eslintrc.yml"
+  ];
+  for (const configFile of eslintConfigFiles) {
+    if (existsSync9(configFile)) {
+      unlinkSync(configFile);
+      console.log(`Removed ${configFile}`);
+    }
+  }
+}
+
+// src/commands/prs.ts
+import { execSync as execSync9 } from "child_process";
+import chalk24 from "chalk";
+import enquirer5 from "enquirer";
+var PAGE_SIZE = 10;
+async function prs(options) {
+  const state = options.open ? "open" : options.closed ? "closed" : "all";
+  try {
+    const result = execSync9(
+      `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100`,
+      { encoding: "utf-8" }
+    );
+    const pullRequests = JSON.parse(result);
+    if (pullRequests.length === 0) {
+      console.log(
+        `No ${state === "all" ? "" : `${state} `}pull requests found.`
+      );
+      return;
+    }
+    await displayPaginated(pullRequests);
+  } catch (error) {
+    if (error instanceof Error) {
+      const msg = error.message.toLowerCase();
+      if (msg.includes("enoent") || msg.includes("command not found")) {
+        console.error("Error: GitHub CLI (gh) is not installed.");
+        console.error("Install it from https://cli.github.com/");
+        return;
+      }
+    }
+    throw error;
+  }
+}
+async function displayPaginated(pullRequests) {
+  const totalPages = Math.ceil(pullRequests.length / PAGE_SIZE);
+  let currentPage = 0;
+  const getStatus = (pr) => {
+    if (pr.state === "MERGED" && pr.mergedAt) {
+      return { label: chalk24.magenta("merged"), date: pr.mergedAt };
+    }
+    if (pr.state === "CLOSED" && pr.closedAt) {
+      return { label: chalk24.red("closed"), date: pr.closedAt };
+    }
+    return { label: chalk24.green("opened"), date: pr.createdAt };
+  };
+  const displayPage = (page) => {
+    const start = page * PAGE_SIZE;
+    const end = Math.min(start + PAGE_SIZE, pullRequests.length);
+    const pagePrs = pullRequests.slice(start, end);
+    console.log(
+      `
+Page ${page + 1} of ${totalPages} (${pullRequests.length} total)
+`
+    );
+    for (const pr of pagePrs) {
+      const status = getStatus(pr);
+      const formattedDate = new Date(status.date).toISOString().split("T")[0];
+      const fileCount = pr.changedFiles.toLocaleString();
+      console.log(
+        `${chalk24.cyan(`#${pr.number}`)} ${pr.title} ${chalk24.dim(`(${pr.author.login},`)} ${status.label} ${chalk24.dim(`${formattedDate})`)}`
+      );
+      console.log(chalk24.dim(`  ${fileCount} files | ${pr.url}`));
+      console.log();
+    }
+  };
+  displayPage(currentPage);
+  if (totalPages <= 1) {
+    return;
+  }
+  while (true) {
+    const hasNext = currentPage < totalPages - 1;
+    const hasPrev = currentPage > 0;
+    const choices = [];
+    if (hasNext) choices.push({ name: "Next page", value: "next" });
+    if (hasPrev) choices.push({ name: "Previous page", value: "prev" });
+    choices.push({ name: "Quit", value: "quit" });
+    const { action } = await enquirer5.prompt({
+      type: "select",
+      name: "action",
+      message: "Navigate",
+      choices
+    });
+    if (action === "Next page") {
+      currentPage++;
+      displayPage(currentPage);
+    } else if (action === "Previous page") {
+      currentPage--;
+      displayPage(currentPage);
+    } else {
+      break;
+    }
+  }
+}
+
+// src/commands/refactor/check.ts
+import { spawn } from "child_process";
+import * as path13 from "path";
+
+// src/commands/refactor/getViolations.ts
+import { execSync as execSync10 } from "child_process";
+import fs10 from "fs";
+import { minimatch } from "minimatch";
+
+// src/commands/refactor/getIgnoredFiles.ts
+import fs9 from "fs";
+var REFACTOR_YML_PATH = "refactor.yml";
+function parseRefactorYml() {
+  if (!fs9.existsSync(REFACTOR_YML_PATH)) {
+    return [];
+  }
+  const content = fs9.readFileSync(REFACTOR_YML_PATH, "utf-8");
+  const entries = [];
+  const lines = content.split("\n");
+  let currentEntry = {};
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- file:")) {
+      if (currentEntry.file) {
+        entries.push(currentEntry);
+      }
+      currentEntry = { file: trimmed.replace("- file:", "").trim() };
+    } else if (trimmed.startsWith("maxLines:")) {
+      currentEntry.maxLines = parseInt(
+        trimmed.replace("maxLines:", "").trim(),
+        10
+      );
+    }
+  }
+  if (currentEntry.file) {
+    entries.push(currentEntry);
+  }
+  return entries;
+}
+function getIgnoredFiles() {
+  const entries = parseRefactorYml();
+  return new Map(entries.map((e) => [e.file, e.maxLines]));
+}
+
+// src/commands/refactor/logViolations.ts
+import chalk25 from "chalk";
+var DEFAULT_MAX_LINES = 100;
+function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
+  if (violations.length === 0) {
+    if (!process.env.CLAUDECODE) {
+      console.log(`Refactor check passed. No files exceed ${maxLines} lines.`);
+    }
+    return;
+  }
+  console.error(chalk25.red(`
+Refactor check failed:
+`));
+  console.error(chalk25.red(`  The following files exceed ${maxLines} lines:
+`));
+  for (const violation of violations) {
+    console.error(chalk25.red(`  ${violation.file} (${violation.lines} lines)`));
+  }
+  console.error(
+    chalk25.yellow(
+      `
+  Each file needs to be sensibly refactored, or if there is no sensible
+  way to refactor it, ignore it with:
+`
+    )
+  );
+  console.error(chalk25.gray(`    assist refactor ignore <file>
+`));
+  if (process.env.CLAUDECODE) {
+    console.error(chalk25.cyan(`
+  ## Extracting Code to New Files
+`));
+    console.error(
+      chalk25.cyan(
+        `  When extracting logic from one file to another, consider where the extracted code belongs:
+`
+      )
+    );
+    console.error(
+      chalk25.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(
+      chalk25.cyan(
+        `  2. Share common utilities: If the extracted code can be reused across multiple
+     domains, move it to a common/shared folder.
+`
+      )
+    );
+  }
+}
+
+// src/commands/refactor/getViolations.ts
+function countLines(filePath) {
+  const content = fs10.readFileSync(filePath, "utf-8");
+  return content.split("\n").length;
+}
+function getGitFiles(options) {
+  if (!options.modified && !options.staged && !options.unstaged) {
+    return null;
+  }
+  const files = /* @__PURE__ */ new Set();
+  if (options.staged || options.modified) {
+    const staged = execSync10("git diff --cached --name-only", {
+      encoding: "utf-8"
+    });
+    for (const file of staged.trim().split("\n").filter(Boolean)) {
+      files.add(file);
+    }
+  }
+  if (options.unstaged || options.modified) {
+    const unstaged = execSync10("git diff --name-only", { encoding: "utf-8" });
+    for (const file of unstaged.trim().split("\n").filter(Boolean)) {
+      files.add(file);
+    }
+  }
+  return files;
+}
+function getViolations(pattern2, options = {}, maxLines = DEFAULT_MAX_LINES) {
+  let sourceFiles = findSourceFiles("src", { includeTests: false });
+  const ignoredFiles = getIgnoredFiles();
+  const gitFiles = getGitFiles(options);
+  if (pattern2) {
+    sourceFiles = sourceFiles.filter((f) => minimatch(f, pattern2));
+  }
+  if (gitFiles) {
+    sourceFiles = sourceFiles.filter((f) => gitFiles.has(f));
+  }
+  const violations = [];
+  for (const filePath of sourceFiles) {
+    const lineCount = countLines(filePath);
+    const maxAllowed = ignoredFiles.get(filePath) ?? maxLines;
+    if (lineCount > maxAllowed) {
+      violations.push({ file: filePath, lines: lineCount });
+    }
+  }
+  return violations;
+}
+
+// src/commands/refactor/check.ts
+async function runVerifyQuietly() {
+  const result = findPackageJsonWithVerifyScripts(process.cwd());
+  if (!result) {
+    return true;
+  }
+  const { packageJsonPath, verifyScripts } = result;
+  const packageDir = path13.dirname(packageJsonPath);
+  const results = await Promise.all(
+    verifyScripts.map(
+      (script) => new Promise(
+        (resolve) => {
+          const child = spawn("npm", ["run", script], {
+            stdio: "pipe",
+            shell: true,
+            cwd: packageDir
+          });
+          let output = "";
+          child.stdout?.on("data", (data) => {
+            output += data.toString();
+          });
+          child.stderr?.on("data", (data) => {
+            output += data.toString();
+          });
+          child.on("close", (code) => {
+            resolve({ script, code: code ?? 1, output });
+          });
+        }
+      )
+    )
+  );
+  const failed = results.filter((r) => r.code !== 0);
+  if (failed.length > 0) {
+    for (const f of failed) {
+      console.error(f.output);
+    }
+    console.error(`
+${failed.length} verify script(s) failed:`);
+    for (const f of failed) {
+      console.error(`  - ${f.script} (exit code ${f.code})`);
+    }
+    return false;
+  }
+  return true;
+}
+async function check(pattern2, options) {
+  const verifyPassed = await runVerifyQuietly();
+  if (!verifyPassed) {
+    process.exit(1);
+  }
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const violations = getViolations(pattern2, options, maxLines);
+  violations.sort((a, b) => b.lines - a.lines);
+  logViolations(violations, maxLines);
+  if (violations.length > 0) {
+    process.exit(1);
+  }
+}
+
+// src/commands/refactor/ignore.ts
+import fs11 from "fs";
+import chalk26 from "chalk";
+var REFACTOR_YML_PATH2 = "refactor.yml";
+function ignore(file) {
+  if (!fs11.existsSync(file)) {
+    console.error(chalk26.red(`Error: File does not exist: ${file}`));
+    process.exit(1);
+  }
+  const content = fs11.readFileSync(file, "utf-8");
+  const lineCount = content.split("\n").length;
+  const maxLines = lineCount + 10;
+  const entry = `- file: ${file}
+  maxLines: ${maxLines}
+`;
+  if (fs11.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs11.readFileSync(REFACTOR_YML_PATH2, "utf-8");
+    fs11.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  } else {
+    fs11.writeFileSync(REFACTOR_YML_PATH2, entry);
+  }
+  console.log(
+    chalk26.green(
+      `Added ${file} to refactor ignore list (max ${maxLines} lines)`
+    )
+  );
+}
+
+// src/commands/run.ts
+import { spawn as spawn2 } from "child_process";
+function run(name, args) {
+  const config = loadConfig();
+  if (!config.run || config.run.length === 0) {
+    console.error("No run configurations found in assist.yml");
+    process.exit(1);
+  }
+  const runConfig = config.run.find((r) => r.name === name);
+  if (!runConfig) {
+    console.error(`No run configuration found with name: ${name}`);
+    console.error("Available configurations:");
+    for (const r of config.run) {
+      console.error(`  - ${r.name}`);
+    }
+    process.exit(1);
+  }
+  const command = runConfig.command.includes(" ") ? `"${runConfig.command}"` : runConfig.command;
+  const allArgs = [...runConfig.args ?? [], ...args];
+  const quotedArgs = allArgs.map(
+    (arg) => arg.includes(" ") ? `"${arg}"` : arg
+  );
+  const fullCommand = [command, ...quotedArgs].join(" ");
+  const child = spawn2(fullCommand, [], {
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+  child.on("error", (err) => {
+    console.error(`Failed to execute command: ${err.message}`);
+    process.exit(1);
+  });
+}
+function add() {
+  const addIndex = process.argv.indexOf("add");
+  if (addIndex === -1 || addIndex + 2 >= process.argv.length) {
+    console.error("Usage: assist run add <name> <command> [args...]");
+    process.exit(1);
+  }
+  const name = process.argv[addIndex + 1];
+  const command = process.argv[addIndex + 2];
+  const args = process.argv.slice(addIndex + 3);
+  const config = loadConfig();
+  if (!config.run) {
+    config.run = [];
+  }
+  const existing = config.run.find((r) => r.name === name);
+  if (existing) {
+    console.error(`Run configuration with name "${name}" already exists`);
+    process.exit(1);
+  }
+  const entry = {
+    name,
+    command
+  };
+  if (args.length > 0) {
+    entry.args = args;
+  }
+  config.run.push(entry);
+  saveConfig(config);
+  const display = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+  console.log(`Added run configuration: ${name} -> ${display}`);
+}
+
+// src/commands/sync.ts
+import * as fs13 from "fs";
+import * as os from "os";
+import * as path15 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// src/commands/sync/syncSettings.ts
+import * as fs12 from "fs";
+import * as path14 from "path";
+import chalk27 from "chalk";
+import enquirer6 from "enquirer";
+async function syncSettings(claudeDir, targetBase) {
+  const source = path14.join(claudeDir, "settings.json");
+  const target = path14.join(targetBase, "settings.json");
+  const sourceContent = fs12.readFileSync(source, "utf-8");
+  const normalizedSource = JSON.stringify(JSON.parse(sourceContent), null, 2);
+  if (fs12.existsSync(target)) {
+    const targetContent = fs12.readFileSync(target, "utf-8");
+    const normalizedTarget = JSON.stringify(JSON.parse(targetContent), null, 2);
+    if (normalizedSource !== normalizedTarget) {
+      console.log(
+        chalk27.yellow("\n\u26A0\uFE0F  Warning: settings.json differs from existing file")
+      );
+      console.log();
+      printDiff(targetContent, sourceContent);
+      const { confirm } = await enquirer6.prompt({
+        type: "confirm",
+        name: "confirm",
+        message: chalk27.red("Overwrite existing settings.json?"),
+        initial: false
+      });
+      if (!confirm) {
+        console.log("Skipped settings.json");
+        return;
+      }
+    }
+  }
+  fs12.copyFileSync(source, target);
+  console.log("Copied settings.json to ~/.claude/settings.json");
+}
+
+// src/commands/sync.ts
+var __filename2 = fileURLToPath4(import.meta.url);
+var __dirname5 = path15.dirname(__filename2);
+async function sync() {
+  const claudeDir = path15.join(__dirname5, "..", "claude");
+  const targetBase = path15.join(os.homedir(), ".claude");
+  syncCommands(claudeDir, targetBase);
+  await syncSettings(claudeDir, targetBase);
+}
+function syncCommands(claudeDir, targetBase) {
+  const sourceDir = path15.join(claudeDir, "commands");
+  const targetDir = path15.join(targetBase, "commands");
+  fs13.mkdirSync(targetDir, { recursive: true });
+  const files = fs13.readdirSync(sourceDir);
+  for (const file of files) {
+    fs13.copyFileSync(path15.join(sourceDir, file), path15.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 execSync11 } from "child_process";
+var pattern = "0x[0-9a-fA-F]{6}|#[0-9a-fA-F]{3,6}";
+function hardcodedColors() {
+  try {
+    const output = execSync11(`grep -rEnH '${pattern}' src/`, {
+      encoding: "utf-8"
+    });
+    const lines = output.trim().split("\n");
+    console.log("Hardcoded colors found:\n");
+    for (const line of lines) {
+      const match = line.match(/^(.+):(\d+):(.+)$/);
+      if (match) {
+        const [, file, lineNum, content] = match;
+        const colorMatch = content.match(/0x[0-9a-fA-F]{6}|#[0-9a-fA-F]{3,6}/);
+        const color = colorMatch?.[0] ?? "unknown";
+        console.log(`${file}:${lineNum} \u2192 ${color}`);
+      }
+    }
+    console.log(`
+Total: ${lines.length} hardcoded color(s)`);
+    console.log("\nUse colors from the 'open-color' (oc) library instead.");
+    console.log("\nExample fix:");
+    console.log("  Before: color: '#228be6'");
+    console.log("  After:  color: oc.blue[6]");
+    console.log("\nImport open-color with: import oc from 'open-color'");
+    process.exit(1);
+  } catch {
+    console.log("No hardcoded colors found.");
+    process.exit(0);
+  }
+}
+
+// src/commands/verify/run.ts
+import { spawn as spawn3 } from "child_process";
+import * as path16 from "path";
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  const seconds = (ms / 1e3).toFixed(1);
+  return `${seconds}s`;
+}
+function printTaskStatuses(tasks) {
+  console.log("\n--- Task Status ---");
+  for (const task of tasks) {
+    if (task.endTime !== void 0) {
+      const duration = formatDuration(task.endTime - task.startTime);
+      const status = task.code === 0 ? "\u2713" : "\u2717";
+      console.log(`  ${status} ${task.script}: ${duration}`);
+    } else {
+      const elapsed = formatDuration(Date.now() - task.startTime);
+      console.log(`  \u22EF ${task.script}: running (${elapsed})`);
+    }
+  }
+  console.log("-------------------\n");
+}
+async function run2(options = {}) {
+  const { timer = false } = options;
+  const result = findPackageJsonWithVerifyScripts(process.cwd());
+  if (!result) {
+    console.log("No package.json with verify:* scripts found");
+    return;
+  }
+  const { packageJsonPath, verifyScripts } = result;
+  const packageDir = path16.dirname(packageJsonPath);
+  console.log(`Running ${verifyScripts.length} verify script(s) in parallel:`);
+  for (const script of verifyScripts) {
+    console.log(`  - ${script}`);
+  }
+  const taskStatuses = verifyScripts.map((script) => ({
+    script,
+    startTime: Date.now()
+  }));
+  const results = await Promise.all(
+    verifyScripts.map(
+      (script, index) => new Promise((resolve) => {
+        const child = spawn3("npm", ["run", script], {
+          stdio: "inherit",
+          shell: true,
+          cwd: packageDir
+        });
+        child.on("close", (code) => {
+          const exitCode = code ?? 1;
+          if (timer) {
+            taskStatuses[index].endTime = Date.now();
+            taskStatuses[index].code = exitCode;
+            printTaskStatuses(taskStatuses);
+          }
+          resolve({ script, code: exitCode });
+        });
+      })
+    )
+  );
+  const failed = results.filter((r) => r.code !== 0);
+  if (failed.length > 0) {
+    console.error(`
+${failed.length} script(s) failed:`);
+    for (const f of failed) {
+      console.error(`  - ${f.script} (exit code ${f.code})`);
+    }
+    process.exit(1);
+  }
+  console.log(`
+All ${verifyScripts.length} verify script(s) passed`);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("assist").description("CLI application").version("1.0.0");
+program.command("sync").description("Copy command files to ~/.claude/commands").action(sync);
+program.command("init").description("Initialize VS Code and verify configurations").action(init5);
+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...");
+  execSync12("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
+});
+program.command("prs").description("List pull requests for the current repository").option("--open", "List only open pull requests").option("--closed", "List only closed pull requests").action(prs);
+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);
+});
+runCommand.command("add").description("Add a new run configuration to assist.yml").allowUnknownOption().allowExcessArguments().action(() => add());
+program.command("new").description("Initialize a new Vite React TypeScript project").action(newProject);
+var verifyCommand = program.command("verify").description("Run all verify:* scripts from package.json in parallel").option("--timer", "Show timing information for each task as they complete").action((options) => run2(options));
+verifyCommand.command("init").description("Add verify scripts to a project").action(init3);
+verifyCommand.command("hardcoded-colors").description("Check for hardcoded hex colors in src/").action(hardcodedColors);
+var lintCommand = program.command("lint").description("Run lint checks for conventions not enforced by biomejs").action(lint);
+lintCommand.command("init").description("Initialize Biome with standard linter config").action(init2);
+var refactorCommand = program.command("refactor").description("Run refactoring checks for code quality");
+refactorCommand.command("check [pattern]").description("Check for files that exceed the maximum line count").option("--modified", "Check only staged and unstaged files").option("--staged", "Check only staged files").option("--unstaged", "Check only unstaged files").option(
+  "--max-lines <number>",
+  "Maximum lines allowed per file (default: 100)",
+  Number.parseInt
+).action(check);
+refactorCommand.command("ignore <file>").description("Add a file to the refactor ignore list").action(ignore);
+var devlogCommand = program.command("devlog").description("Development log utilities");
+devlogCommand.command("list").description("Group git commits by date").option(
+  "--days <number>",
+  "Number of days to show (default: 30)",
+  Number.parseInt
+).option("--since <date>", "Only show commits since this date (YYYY-MM-DD)").option("-r, --reverse", "Show earliest commits first").option("-v, --verbose", "Show file names for each commit").action(list);
+devlogCommand.command("version").description("Show current repo name and version info").action(version);
+devlogCommand.command("next").description("Show commits for the day after the last versioned entry").option("-v, --verbose", "Show file names for each commit").action(next);
+devlogCommand.command("skip <date>").description("Add a date (YYYY-MM-DD) to the skip list").action(skip);
+var vscodeCommand = program.command("vscode").description("VS Code configuration utilities");
+vscodeCommand.command("init").description("Add VS Code configuration files").action(init4);
+var deployCommand = program.command("deploy").description("Netlify deployment utilities");
+deployCommand.command("init").description("Initialize Netlify project and configure deployment").action(init);
+program.command("enable-ralph").description("Enable ralph-wiggum plugin for spacetraders").action(enableRalph);
+program.parse();