@staff0rd/assist 0.10.1

package/README.md

@@ -0,0 +1,44 @@
+# assist
+
+A CLI tool for enforcing determinism in LLM development workflow automation.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone git@github.com:staff0rd/assist.git
+cd assist
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Install globally
+npm install -g .
+```
+
+After installation, the `assist` command will be available globally.
+
+## Commands
+
+- `assist init` - Initialize project with VS Code and verify configurations
+- `assist new` - Initialize a new Vite React TypeScript project
+- `assist sync` - Copy command files to `~/.claude/commands`
+- `assist commit <message>` - Create a git commit with validation
+- `assist update` - Update claude-code to the latest version
+- `assist verify` - Run all verify:* scripts from package.json in parallel
+- `assist verify init` - Add verify scripts to a project
+- `assist verify hardcoded-colors` - Check for hardcoded hex colors in src/
+- `assist lint` - Run lint checks for conventions not enforced by biomejs
+- `assist lint init` - Initialize Biome with standard linter config
+- `assist refactor check [pattern]` - Check for files that exceed the maximum line count
+- `assist refactor ignore <file>` - Add a file to the refactor ignore list
+- `assist devlog list` - Group git commits by date
+- `assist devlog next` - Show commits for the day after the last versioned entry
+- `assist devlog skip <date>` - Add a date to the skip list
+- `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
+

package/dist/commands/deploy/build.yml

@@ -0,0 +1,25 @@
+name: Build and Deploy to Netlify
+on:
+  push:
+    branches:
+      - main
+jobs:
+  build_and_deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        name: Checkout
+
+      - uses: actions/setup-node@v4
+        name: Setup Node.js
+        with:
+          node-version: "22"
+
+      - run: npm ci
+        name: Install dependencies
+
+      - run: npm run build
+        name: Build project
+
+      - run: npx netlify-cli deploy --no-build --dir=dist --prod -s {{NETLIFY_SITE_ID}} --auth ${{ secrets.NETLIFY_AUTH_TOKEN }} --message "Deployed commit ${{ github.sha }}"
+        name: Deploy to Netlify

package/dist/commands/deploy/init.ts

@@ -0,0 +1,104 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import enquirer from "enquirer";
+import { printDiff } from "../../utils/printDiff";
+
+const WORKFLOW_PATH = ".github/workflows/build.yml";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function getExistingSiteId(): string | null {
+	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: string): string {
+	const templatePath = join(__dirname, "commands/deploy/build.yml");
+	const template = readFileSync(templatePath, "utf-8");
+	return template.replace("{{NETLIFY_SITE_ID}}", siteId);
+}
+
+async function updateWorkflow(siteId: string): Promise<void> {
+	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(chalk.green("build.yml is already up to date"));
+			return;
+		}
+
+		console.log(chalk.yellow("\nbuild.yml will be updated:"));
+		console.log();
+		printDiff(oldContent, newContent);
+
+		const { confirm } = await enquirer.prompt<{ confirm: boolean }>({
+			type: "confirm",
+			name: "confirm",
+			message: chalk.red("Update build.yml?"),
+			initial: true,
+		});
+
+		if (!confirm) {
+			console.log("Skipped build.yml update");
+			return;
+		}
+	}
+
+	writeFileSync(WORKFLOW_PATH, newContent);
+	console.log(chalk.green(`\nCreated ${WORKFLOW_PATH}`));
+}
+
+export async function init(): Promise<void> {
+	console.log(chalk.bold("Initializing Netlify deployment...\n"));
+
+	const existingSiteId = getExistingSiteId();
+
+	if (existingSiteId) {
+		console.log(chalk.dim(`Using existing site ID: ${existingSiteId}\n`));
+		await updateWorkflow(existingSiteId);
+		return;
+	}
+
+	console.log("Creating Netlify site...\n");
+	execSync("netlify sites:create --disable-linking", {
+		stdio: "inherit",
+	});
+
+	const { siteId } = await enquirer.prompt<{ siteId: string }>({
+		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(chalk.bold("\nDeployment initialized successfully!"));
+	console.log(
+		chalk.yellow("\nTo complete setup, create a personal access token at:"),
+	);
+	console.log(
+		chalk.cyan(
+			"https://app.netlify.com/user/applications#personal-access-tokens",
+		),
+	);
+	console.log(
+		chalk.yellow(
+			"\nThen add it as NETLIFY_AUTH_TOKEN in your GitHub repository secrets.",
+		),
+	);
+}

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

@@ -0,0 +1,83 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import enquirer from "enquirer";
+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 enquirer.prompt<{ confirm: boolean }>({
+		type: "confirm",
+		name: "confirm",
+		message: "Apply these changes?",
+		initial: true,
+	});
+
+	if (!confirm) {
+		console.log("Skipped");
+		return;
+	}
+
+	fs.writeFileSync(targetPath, mergedContent);
+	console.log(`Updated ${targetPath}`);
+}

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

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

package/dist/commands/lint/biome.linter.json

@@ -0,0 +1,57 @@
+{
+	"overrides": [
+		{
+			"includes": ["**/constants.ts"],
+			"linter": {
+				"rules": {
+					"style": {
+						"useFilenamingConvention": {
+							"level": "error",
+							"options": {
+								"filenameCases": ["kebab-case"],
+								"requireAscii": true
+							}
+						}
+					}
+				}
+			}
+		},
+		{
+			"includes": ["**/*.test.ts"],
+			"linter": {
+				"rules": {
+					"style": {
+						"useFilenamingConvention": "off"
+					}
+				}
+			}
+		}
+	],
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"style": {
+				"useFilenamingConvention": {
+					"level": "error",
+					"options": {
+						"filenameCases": ["export"],
+						"requireAscii": true
+					}
+				},
+				"useConsistentTypeDefinitions": {
+					"level": "error",
+					"options": {
+						"style": "type"
+					}
+				},
+				"useConsistentMemberAccessibility": {
+					"level": "error",
+					"options": {
+						"accessibility": "noPublic"
+					}
+				}
+			}
+		}
+	}
+}

package/dist/commands/lint/init.ts

@@ -0,0 +1,58 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import enquirer from "enquirer";
+import { printDiff } from "../../utils/printDiff";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export async function init(): Promise<void> {
+	const biomeConfigPath = "biome.json";
+
+	if (!existsSync(biomeConfigPath)) {
+		console.log("Initializing Biome...");
+		execSync("npx @biomejs/biome init", { stdio: "inherit" });
+	}
+
+	if (!existsSync(biomeConfigPath)) {
+		console.log("No biome.json found, skipping linter config");
+		return;
+	}
+
+	const linterConfigPath = join(__dirname, "commands/lint/biome.linter.json");
+	const linterConfig = JSON.parse(readFileSync(linterConfigPath, "utf-8"));
+	const biomeConfig = JSON.parse(readFileSync(biomeConfigPath, "utf-8"));
+
+	const oldContent = `${JSON.stringify(biomeConfig, null, 2)}\n`;
+	biomeConfig.linter = linterConfig.linter;
+	if (linterConfig.overrides) {
+		biomeConfig.overrides = linterConfig.overrides;
+	}
+	const newContent = `${JSON.stringify(biomeConfig, null, 2)}\n`;
+
+	if (oldContent === newContent) {
+		console.log("biome.json already has the correct linter config");
+		return;
+	}
+
+	console.log(chalk.yellow("\n⚠️  biome.json will be updated:"));
+	console.log();
+	printDiff(oldContent, newContent);
+
+	const { confirm } = await enquirer.prompt<{ confirm: boolean }>({
+		type: "confirm",
+		name: "confirm",
+		message: chalk.red("Update biome.json?"),
+		initial: true,
+	});
+
+	if (!confirm) {
+		console.log("Skipped biome.json update");
+		return;
+	}
+
+	writeFileSync(biomeConfigPath, newContent);
+	console.log("Updated biome.json with linter config");
+}

package/dist/commands/lint/lint.ts

@@ -0,0 +1,12 @@
+// Implements conventions not enforced by biomejs
+import { runFileNameCheck } from "./runFileNameCheck";
+import { runStaticImportCheck } from "./runStaticImportCheck";
+
+export function lint(): void {
+	const fileNamePassed = runFileNameCheck();
+	const staticImportPassed = runStaticImportCheck();
+
+	if (!fileNamePassed || !staticImportPassed) {
+		process.exit(1);
+	}
+}

package/dist/commands/lint/runFileNameCheck.ts

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { findSourceFiles } from "../../shared/findSourceFiles";
+
+type FileNameViolation = {
+	filePath: string;
+	fileName: string;
+};
+
+function hasClassOrComponent(content: string): boolean {
+	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(): FileNameViolation[] {
+	const sourceFiles = findSourceFiles("src");
+	const violations: FileNameViolation[] = [];
+
+	for (const filePath of sourceFiles) {
+		const fileName = path.basename(filePath);
+		const nameWithoutExt = fileName.replace(/\.(ts|tsx)$/, "");
+
+		if (/^[A-Z]/.test(nameWithoutExt)) {
+			const content = fs.readFileSync(filePath, "utf-8");
+			if (!hasClassOrComponent(content)) {
+				violations.push({ filePath, fileName });
+			}
+		}
+	}
+
+	return violations;
+}
+
+export function runFileNameCheck(): boolean {
+	const violations = checkFileNames();
+	if (violations.length > 0) {
+		console.error(chalk.red("\nFile name check failed:\n"));
+		console.error(
+			chalk.red(
+				"  Files without classes or React components should not start with a capital letter.\n",
+			),
+		);
+		for (const violation of violations) {
+			console.error(chalk.red(`  ${violation.filePath}`));
+			console.error(
+				chalk.gray(
+					`    Rename to: ${violation.fileName.charAt(0).toLowerCase()}${violation.fileName.slice(1)}\n`,
+				),
+			);
+		}
+		return false;
+	}
+
+	if (!process.env.CLAUDECODE) {
+		console.log(
+			"File name check passed. All PascalCase files contain classes or components.",
+		);
+	}
+	return true;
+}

package/dist/commands/lint/runStaticImportCheck.ts

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import chalk from "chalk";
+import { findSourceFiles } from "../../shared/findSourceFiles";
+
+type ImportViolation = {
+	filePath: string;
+	line: number;
+	content: string;
+};
+
+function checkForDynamicImports(filePath: string): ImportViolation[] {
+	const content = fs.readFileSync(filePath, "utf-8");
+	const lines = content.split("\n");
+	const violations: ImportViolation[] = [];
+
+	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(): ImportViolation[] {
+	const sourceFiles = findSourceFiles("src");
+	const violations: ImportViolation[] = [];
+
+	for (const filePath of sourceFiles) {
+		violations.push(...checkForDynamicImports(filePath));
+	}
+
+	return violations;
+}
+
+export function runStaticImportCheck(): boolean {
+	const violations = checkStaticImports();
+	if (violations.length > 0) {
+		console.error(chalk.red("\nStatic import check failed:\n"));
+		console.error(
+			chalk.red(
+				"  Dynamic imports (require() and import()) are not allowed. Use static imports instead.\n",
+			),
+		);
+		for (const violation of violations) {
+			console.error(chalk.red(`  ${violation.filePath}:${violation.line}`));
+			console.error(chalk.gray(`    ${violation.content}\n`));
+		}
+		return false;
+	}
+
+	if (!process.env.CLAUDECODE) {
+		console.log("Static import check passed. No dynamic imports found.");
+	}
+	return true;
+}