claudenv 1.0.1

package/src/prompts.js

@@ -0,0 +1,267 @@
+import { input, select, confirm, checkbox } from '@inquirer/prompts';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { FRAMEWORKS_BY_LANGUAGE } from './constants.js';
+
+/**
+ * Interactive flow for an existing project with detected tech stack.
+ * @param {object} detected - Output from detectTechStack()
+ * @returns {Promise<object>} Config object for the generator
+ */
+export async function runExistingProjectFlow(detected) {
+  console.log('\nDetected tech stack:');
+  console.log(`  Language:        ${detected.language || 'unknown'}`);
+  if (detected.framework) console.log(`  Framework:       ${detected.framework}`);
+  if (detected.packageManager) console.log(`  Package manager: ${detected.packageManager}`);
+  if (detected.testFramework) console.log(`  Test framework:  ${detected.testFramework}`);
+  if (detected.linter) console.log(`  Linter:          ${detected.linter}`);
+  if (detected.formatter) console.log(`  Formatter:       ${detected.formatter}`);
+  if (detected.ci) console.log(`  CI/CD:           ${detected.ci}`);
+  if (detected.monorepo) console.log(`  Monorepo:        ${detected.monorepo}`);
+  console.log();
+
+  const projectDescription = await input({
+    message: 'Brief project description:',
+    default: `${detected.framework || detected.language} project`,
+  });
+
+  const projectType = await select({
+    message: 'What type of project is this?',
+    choices: [
+      { value: 'web-app', name: 'Web application' },
+      { value: 'api', name: 'API service' },
+      { value: 'cli', name: 'CLI tool' },
+      { value: 'library', name: 'Library / package' },
+      { value: 'monorepo', name: 'Monorepo' },
+      { value: 'other', name: 'Other' },
+    ],
+  });
+
+  const deployment = await select({
+    message: 'Deployment target?',
+    choices: [
+      { value: 'vercel', name: 'Vercel' },
+      { value: 'aws', name: 'AWS' },
+      { value: 'docker', name: 'Docker / Kubernetes' },
+      { value: 'fly-io', name: 'Fly.io' },
+      { value: 'railway', name: 'Railway' },
+      { value: 'bare-metal', name: 'Bare metal / VPS' },
+      { value: 'none', name: 'Not yet decided' },
+    ],
+  });
+
+  const conventions = await input({
+    message: 'Any team conventions not captured in config files? (leave empty to skip)',
+    default: '',
+  });
+
+  const focusAreas = await input({
+    message: 'Areas of the codebase Claude should pay special attention to? (leave empty to skip)',
+    default: '',
+  });
+
+  const generateRules = await confirm({
+    message: 'Generate .claude/rules/ files for code style and testing?',
+    default: true,
+  });
+
+  const generateHooks = await confirm({
+    message: 'Generate validation hooks in .claude/settings.json?',
+    default: true,
+  });
+
+  return {
+    ...detected,
+    projectDescription,
+    projectType,
+    deployment: deployment === 'none' ? null : deployment,
+    conventions: conventions || null,
+    focusAreas: focusAreas || null,
+    generateRules,
+    generateHooks,
+    rules: buildRules(detected, focusAreas),
+  };
+}
+
+/**
+ * Interactive flow for a new/empty project (cold start).
+ * @returns {Promise<object>} Config object for the generator
+ */
+export async function runColdStartFlow() {
+  console.log('\nNo project files detected. Starting from scratch.\n');
+
+  const projectDescription = await input({
+    message: 'What is this project?',
+  });
+
+  const language = await select({
+    message: 'Primary language?',
+    choices: [
+      { value: 'typescript', name: 'TypeScript' },
+      { value: 'javascript', name: 'JavaScript' },
+      { value: 'python', name: 'Python' },
+      { value: 'go', name: 'Go' },
+      { value: 'rust', name: 'Rust' },
+      { value: 'ruby', name: 'Ruby' },
+      { value: 'php', name: 'PHP' },
+      { value: 'java', name: 'Java' },
+      { value: 'kotlin', name: 'Kotlin' },
+      { value: 'csharp', name: 'C#' },
+    ],
+  });
+
+  const frameworks = FRAMEWORKS_BY_LANGUAGE[language] || ['None'];
+  const framework = await select({
+    message: 'Framework?',
+    choices: frameworks.map((f) => ({ value: f.toLowerCase().replace(/\s+/g, '-'), name: f })),
+  });
+
+  const projectType = await select({
+    message: 'Project type?',
+    choices: [
+      { value: 'web-app', name: 'Web application' },
+      { value: 'api', name: 'API service' },
+      { value: 'cli', name: 'CLI tool' },
+      { value: 'library', name: 'Library / package' },
+      { value: 'other', name: 'Other' },
+    ],
+  });
+
+  const deployment = await select({
+    message: 'Deployment target?',
+    choices: [
+      { value: 'vercel', name: 'Vercel' },
+      { value: 'aws', name: 'AWS' },
+      { value: 'docker', name: 'Docker / Kubernetes' },
+      { value: 'fly-io', name: 'Fly.io' },
+      { value: 'railway', name: 'Railway' },
+      { value: 'bare-metal', name: 'Bare metal / VPS' },
+      { value: 'none', name: 'Not yet decided' },
+    ],
+  });
+
+  const conventions = await input({
+    message: 'Any coding conventions to enforce? (leave empty to skip)',
+    default: '',
+  });
+
+  const generateRules = await confirm({
+    message: 'Generate .claude/rules/ files?',
+    default: true,
+  });
+
+  const generateHooks = await confirm({
+    message: 'Generate validation hooks?',
+    default: true,
+  });
+
+  return {
+    language,
+    runtime: inferRuntime(language),
+    framework: framework === 'none' ? null : framework,
+    packageManager: inferPackageManager(language),
+    testFramework: null,
+    linter: null,
+    formatter: null,
+    ci: null,
+    containerized: false,
+    monorepo: null,
+    projectDescription,
+    projectType,
+    deployment: deployment === 'none' ? null : deployment,
+    conventions: conventions || null,
+    generateRules,
+    generateHooks,
+    suggestedDevCmd: null,
+    suggestedBuildCmd: null,
+    suggestedTestCmd: null,
+    rules: [],
+  };
+}
+
+function inferRuntime(language) {
+  const runtimeMap = {
+    typescript: 'node',
+    javascript: 'node',
+    python: 'python',
+    go: 'go',
+    rust: 'rust',
+    ruby: 'ruby',
+    php: 'php',
+    java: 'jvm',
+    kotlin: 'jvm',
+    csharp: 'dotnet',
+  };
+  return runtimeMap[language] || language;
+}
+
+function inferPackageManager(language) {
+  const pmMap = {
+    typescript: 'npm',
+    javascript: 'npm',
+    python: 'pip',
+    ruby: 'bundler',
+    php: 'composer',
+    rust: 'cargo',
+    go: 'go-modules',
+  };
+  return pmMap[language] || null;
+}
+
+/**
+ * Build config from auto-detected values without prompting (--yes mode).
+ * @param {object} detected - Output from detectTechStack()
+ * @param {string} projectDir - Project root directory
+ * @returns {Promise<object>} Config object for the generator
+ */
+export async function buildDefaultConfig(detected, projectDir) {
+  let projectDescription = `${detected.framework || detected.language || 'Unknown'} project`;
+
+  // Try to get a better name from package.json
+  try {
+    const pkgRaw = await readFile(join(projectDir, 'package.json'), 'utf-8');
+    const pkg = JSON.parse(pkgRaw);
+    if (pkg.description) {
+      projectDescription = pkg.description;
+    } else if (pkg.name) {
+      projectDescription = `${pkg.name} — ${detected.framework || detected.language} project`;
+    }
+  } catch {
+    // No package.json or parse error
+  }
+
+  return {
+    ...detected,
+    projectDescription,
+    projectType: null,
+    deployment: null,
+    conventions: null,
+    focusAreas: null,
+    generateRules: true,
+    generateHooks: true,
+    rules: buildRules(detected, null),
+  };
+}
+
+function buildRules(detected, focusAreas) {
+  const rules = [];
+
+  if (detected.framework === 'next.js') {
+    rules.push('Use server components by default; add \'use client\' only when needed');
+    rules.push('Prefer server actions for mutations over API routes');
+  }
+
+  if (detected.framework === 'django') {
+    rules.push('NEVER modify migration files after they have been committed');
+  }
+
+  if (detected.linter) {
+    rules.push(`Run \`${detected.suggestedLintCmd || detected.linter}\` before committing`);
+  }
+
+  if (focusAreas) {
+    rules.push(`Pay special attention to: ${focusAreas}`);
+  }
+
+  return rules;
+}

package/src/validator.js

@@ -0,0 +1,206 @@
+import { readFile, access } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { REQUIRED_SECTIONS } from './constants.js';
+
+/**
+ * Validate a CLAUDE.md file for required structure and content.
+ * @param {string} filePath - Absolute path to CLAUDE.md
+ * @returns {Promise<{valid: boolean, errors: string[], warnings: string[]}>}
+ */
+export async function validateClaudeMd(filePath) {
+  const errors = [];
+  const warnings = [];
+
+  // Check file exists and is non-empty
+  let content;
+  try {
+    content = await readFile(filePath, 'utf-8');
+  } catch {
+    errors.push(`File not found: ${filePath}`);
+    return { valid: false, errors, warnings };
+  }
+
+  if (!content.trim()) {
+    errors.push('CLAUDE.md is empty');
+    return { valid: false, errors, warnings };
+  }
+
+  // Check required sections
+  for (const section of REQUIRED_SECTIONS) {
+    if (!content.includes(section)) {
+      errors.push(`Missing required section: ${section}`);
+    }
+  }
+
+  // Check for a top-level heading
+  if (!content.match(/^#\s+\S/m)) {
+    warnings.push('No top-level heading (# Title) found');
+  }
+
+  // Check that ## Commands section has at least one command
+  const commandsMatch = content.match(/## Commands\n([\s\S]*?)(?=\n## |\n# |$)/);
+  if (commandsMatch) {
+    const commandsContent = commandsMatch[1].trim();
+    if (!commandsContent.includes('`')) {
+      warnings.push('## Commands section has no inline code (expected command examples)');
+    }
+  }
+
+  // Check @imports resolve to real files
+  const importErrors = await validateImports(content, dirname(filePath));
+  errors.push(...importErrors);
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+/**
+ * Validate the .claude/ directory structure.
+ * @param {string} projectDir - Project root directory
+ * @returns {Promise<{valid: boolean, errors: string[], warnings: string[]}>}
+ */
+export async function validateStructure(projectDir) {
+  const errors = [];
+  const warnings = [];
+
+  // Check CLAUDE.md exists
+  const claudeMdPath = join(projectDir, 'CLAUDE.md');
+  try {
+    await access(claudeMdPath);
+  } catch {
+    errors.push('CLAUDE.md not found in project root');
+  }
+
+  // Check .claude directory structure
+  const optionalPaths = [
+    { path: '.claude/commands', label: 'commands directory' },
+    { path: '.claude/rules', label: 'rules directory' },
+    { path: '.claude/settings.json', label: 'settings.json' },
+  ];
+
+  for (const { path, label } of optionalPaths) {
+    try {
+      await access(join(projectDir, path));
+    } catch {
+      warnings.push(`Optional ${label} not found at ${path}`);
+    }
+  }
+
+  // If settings.json exists, validate it's valid JSON
+  try {
+    const settingsRaw = await readFile(join(projectDir, '.claude/settings.json'), 'utf-8');
+    JSON.parse(settingsRaw);
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      errors.push(`.claude/settings.json is not valid JSON: ${err.message}`);
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+/**
+ * Cross-reference documentation with actual project files.
+ * @param {string} projectDir - Project root directory
+ * @returns {Promise<{valid: boolean, errors: string[], warnings: string[]}>}
+ */
+export async function crossReferenceCheck(projectDir) {
+  const errors = [];
+  const warnings = [];
+
+  const claudeMdPath = join(projectDir, 'CLAUDE.md');
+  let content;
+  try {
+    content = await readFile(claudeMdPath, 'utf-8');
+  } catch {
+    errors.push('CLAUDE.md not found — cannot cross-reference');
+    return { valid: false, errors, warnings };
+  }
+
+  // Check that directories mentioned in Architecture section exist
+  const archMatch = content.match(/## Architecture\n([\s\S]*?)(?=\n## |\n# |$)/);
+  if (archMatch) {
+    const archContent = archMatch[1];
+    const dirRefs = archContent.match(/`([^`]+\/)`/g);
+    if (dirRefs) {
+      for (const ref of dirRefs) {
+        const dirPath = ref.replace(/`/g, '');
+        try {
+          await access(join(projectDir, dirPath));
+        } catch {
+          warnings.push(`Architecture references directory "${dirPath}" which does not exist`);
+        }
+      }
+    }
+  }
+
+  // Check that referenced scripts in Commands section exist in package.json
+  const pkgJsonPath = join(projectDir, 'package.json');
+  try {
+    const pkgRaw = await readFile(pkgJsonPath, 'utf-8');
+    const pkg = JSON.parse(pkgRaw);
+    const scripts = pkg.scripts || {};
+
+    const cmdMatch = content.match(/## Commands\n([\s\S]*?)(?=\n## |\n# |$)/);
+    if (cmdMatch) {
+      const cmdContent = cmdMatch[1];
+      // Look for `npm run <script>` or `pnpm <script>` or `yarn <script>` patterns
+      const scriptRefs = cmdContent.matchAll(/(?:npm run|pnpm|yarn|bun(?:x| run)?)\s+([a-z][\w:-]*)/g);
+      for (const match of scriptRefs) {
+        const scriptName = match[1];
+        if (!scripts[scriptName]) {
+          warnings.push(`Commands section references script "${scriptName}" not found in package.json`);
+        }
+      }
+    }
+  } catch {
+    // No package.json or parse error — skip script checks
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+/**
+ * Validate @import references in CLAUDE.md content.
+ */
+async function validateImports(content, baseDir) {
+  const errors = [];
+  const lines = content.split('\n');
+  let inCodeBlock = false;
+
+  for (const line of lines) {
+    if (line.trimStart().startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+
+    // Match bare @path references (not inside code blocks, not email addresses)
+    const importMatch = line.match(/^@([^\s@]+)$/);
+    if (importMatch) {
+      const importPath = importMatch[1];
+      const resolvedPath = importPath.startsWith('~/')
+        ? join(process.env.HOME || '', importPath.slice(2))
+        : join(baseDir, importPath);
+
+      try {
+        await access(resolvedPath);
+      } catch {
+        errors.push(`@import reference "${importPath}" does not resolve to a file`);
+      }
+    }
+  }
+
+  return errors;
+}

package/templates/claude-md.ejs

@@ -0,0 +1,49 @@
+# CLAUDE.md
+
+## Project overview
+<%= projectDescription || `${language || 'Unknown'} project` %><% if (framework) { %> built with <%= framework %><% } %><% if (runtime && runtime !== language) { %> on <%= runtime %><% } %>.
+<% if (deployment) { %>Deployed to <%= deployment %>.<% } %>
+
+## Commands
+<% if (commands.dev) { %>- `<%= commands.dev %>` — Start development server
+<% } -%>
+<% if (commands.build) { %>- `<%= commands.build %>` — Production build
+<% } -%>
+<% if (commands.test) { %>- `<%= commands.test %>` — Run tests
+<% } -%>
+<% if (commands.lint) { %>- `<%= commands.lint %>` — Run linter
+<% } -%>
+<% if (commands.migrate) { %>- `<%= commands.migrate %>` — Run database migrations
+<% } -%>
+<% if (commands.format) { %>- `<%= commands.format %>` — Format code
+<% } -%>
+<% if (additionalCommands && additionalCommands.length > 0) { -%>
+<% for (const cmd of additionalCommands) { %>- `<%= cmd.command %>` — <%= cmd.description %>
+<% } -%>
+<% } %>
+## Architecture
+<% if (directories && directories.length > 0) { -%>
+<% for (const dir of directories) { %>- `<%= dir.path %>` — <%= dir.description %>
+<% } -%>
+<% } else { %>Describe the key directories and their purposes here.
+<% } %>
+## Conventions
+<% if (generateRules) { %>@.claude/rules/code-style.md
+@.claude/rules/testing.md
+<% } -%>
+<% if (conventions) { %><%= conventions %>
+<% } %>
+## Workflow
+<% if (generateRules) { %>@.claude/rules/workflow.md
+<% } else { %>- Use plan mode for complex tasks; read code before editing
+- Use `/compact` when context fills up, `/clear` between unrelated tasks
+- NEVER create .md files (README, CONTRIBUTING, CHANGELOG, etc.) unless explicitly asked
+<% } %>
+## Memory
+Project state is tracked in `_state.md` at the project root. Review it at session start, update after significant decisions.
+<% if (rules && rules.length > 0) { %>
+## Rules
+<% for (const rule of rules) { %>- <%- rule %>
+<% } -%>
+<% } %>
+- NEVER create documentation files (.md) unless the user explicitly requests it

package/templates/rules-code-style.ejs

@@ -0,0 +1,64 @@
+<% if (pathGlobs && pathGlobs.length > 0) { %>---
+paths:
+<% for (const g of pathGlobs) { %>  - "<%= g %>"
+<% } %>---
+<% } %># Code Style Rules
+
+<% if (language === 'typescript' || language === 'javascript') { %>## TypeScript/JavaScript
+- Use <%= formatter || 'consistent' %> formatting<% if (linter) { %> with <%= linter %> for linting<% } %>
+<% if (language === 'typescript') { %>- Prefer `interface` over `type` for object shapes that may be extended
+- Use strict TypeScript (`"strict": true`) — avoid `any`, prefer `unknown`
+<% } -%>
+- Use named exports over default exports
+- Prefer `const` over `let`; never use `var`
+- Use template literals for string interpolation
+<% if (framework === 'next.js') { %>
+## Next.js Conventions
+- Use server components by default; add `'use client'` only when needed
+- Prefer server actions for mutations over API routes
+- Colocate page-specific components in the route directory
+<% } -%>
+<% if (framework === 'vite') { %>
+## Component Conventions
+- One component per file
+- Name files after the component they export
+<% } -%>
+<% } -%>
+
+<% if (language === 'python') { %>## Python
+<% if (linter === 'ruff') { %>- Use Ruff for linting and formatting
+<% } else { %>- Follow PEP 8 style guidelines
+<% } -%>
+- Use type hints for all function signatures
+- Prefer f-strings for string formatting
+- Use `pathlib.Path` over `os.path`
+<% if (framework === 'django') { %>
+## Django Conventions
+- Fat models, thin views
+- Use class-based views for CRUD operations
+- Keep business logic in model methods or services
+<% } -%>
+<% if (framework === 'fastapi') { %>
+## FastAPI Conventions
+- Use Pydantic models for request/response schemas
+- Group routes by resource in separate routers
+<% } -%>
+<% } -%>
+
+<% if (language === 'go') { %>## Go
+- Follow Effective Go and Go Code Review Comments
+- Use `errors.Is` / `errors.As` for error comparison
+- Accept interfaces, return structs
+- Keep packages small and focused
+<% } -%>
+
+<% if (language === 'rust') { %>## Rust
+- Use `clippy` for linting
+- Prefer `Result` over `panic!` for recoverable errors
+- Use `thiserror` for library error types, `anyhow` for applications
+<% } -%>
+
+## General
+- Keep functions focused — one responsibility per function
+- Name variables and functions descriptively; avoid abbreviations
+<% if (conventions) { %><%= conventions %><% } %>

package/templates/rules-testing.ejs

@@ -0,0 +1,64 @@
+<% if (testPathGlobs && testPathGlobs.length > 0) { %>---
+paths:
+<% for (const g of testPathGlobs) { %>  - "<%= g %>"
+<% } %>---
+<% } %># Testing Rules
+
+## Test Framework
+<% if (testFramework) { %>Using **<%= testFramework %>** for testing.
+<% } else { %>No test framework detected. Configure one before writing tests.
+<% } %>
+
+## Commands
+<% if (commands.test) { %>- Run all tests: `<%= commands.test %>`
+<% } -%>
+<% if (commands.testSingle) { %>- Run single test: `<%= commands.testSingle %>`
+<% } -%>
+<% if (commands.testWatch) { %>- Watch mode: `<%= commands.testWatch %>`
+<% } -%>
+<% if (commands.testCoverage) { %>- Coverage: `<%= commands.testCoverage %>`
+<% } %>
+
+<% if (testFramework === 'vitest' || testFramework === 'jest') { %>## Patterns
+- Place tests adjacent to source files as `*.test.ts` or in `__tests__/` directories
+- Use `describe` blocks to group related tests
+- Use `it` (not `test`) for test cases
+- Name tests descriptively: `it('should return 404 when user not found')`
+- Prefer `toEqual` for objects, `toBe` for primitives
+- Use `vi.mock()` / `jest.mock()` for module mocking
+<% } -%>
+
+<% if (testFramework === 'pytest') { %>## Patterns
+- Place tests in `tests/` directory mirroring `src/` structure
+- Name test files `test_*.py` and test functions `test_*`
+- Use fixtures for shared setup (`conftest.py`)
+- Use `parametrize` for testing multiple inputs
+- Prefer `assert` statements over `self.assert*` methods
+<% } -%>
+
+<% if (testFramework === 'rspec') { %>## Patterns
+- Place specs in `spec/` mirroring `app/` structure
+- Use `let` and `before` for shared setup
+- Use `context` blocks for conditional scenarios
+- Use factories (FactoryBot) over fixtures
+<% } -%>
+
+<% if (language === 'go') { %>## Patterns
+- Place tests in the same package as the code under test
+- Name test files `*_test.go`
+- Use table-driven tests for multiple cases
+- Use `testify/assert` or standard `testing.T` methods
+<% } -%>
+
+<% if (language === 'rust') { %>## Patterns
+- Place unit tests in `#[cfg(test)] mod tests` at the bottom of each file
+- Place integration tests in `tests/` directory
+- Use `#[test]` attribute for test functions
+- Use `assert_eq!`, `assert_ne!`, `assert!` macros
+<% } -%>
+
+## Guidelines
+- Every bug fix should include a regression test
+- Test behavior, not implementation details
+- Keep tests independent — no shared mutable state between tests
+<% if (testConventions) { %><%= testConventions %><% } %>

package/templates/rules-workflow.ejs

@@ -0,0 +1,49 @@
+---
+<% if (pathGlobs && pathGlobs.length > 0) { -%>
+paths:
+<% for (const glob of pathGlobs) { %>  - "<%= glob %>"
+<% } -%>
+<% } -%>
+---
+
+# Workflow Best Practices
+
+## Planning
+- Use **plan mode** for complex tasks, unclear requirements, or multi-file changes
+- Break large changes into small, reviewable steps
+- Read existing code before proposing modifications — understand context first
+
+## Context Management
+- Use `/compact` when the conversation gets long and context fills up
+- Use `/clear` when switching between unrelated tasks
+- Keep CLAUDE.md concise (< 60 lines) — move details into @imported rule files
+
+## Subagents
+- Delegate research and exploration to subagents when scanning large codebases
+- Use subagents for parallel investigation of independent questions
+- Keep the main conversation focused on implementation decisions
+
+## Memory
+- Use `_state.md` in the project root to track decisions, current focus, and known issues
+- Update `_state.md` when making significant architectural decisions
+- Review `_state.md` at the start of each session to restore context
+
+## Commits and Git
+- NEVER commit unless the user explicitly asks
+- NEVER push to remote without explicit permission
+- NEVER amend published commits or force-push without explicit permission
+- Write clear, descriptive commit messages explaining "why" not "what"
+
+## File Discipline
+- NEVER create documentation files (.md) unless explicitly requested by the user
+- This includes: README.md, CONTRIBUTING.md, CHANGELOG.md, docs/*.md, and any other markdown files
+- Only modify or create files that are directly needed for the current task
+- Prefer editing existing files over creating new ones
+- Do not add comments, docstrings, or type annotations to code you did not change
+
+## Code Changes
+- Always read a file before editing it
+- Make minimal, focused changes — do not refactor surrounding code unless asked
+- Do not add error handling, validation, or abstractions for hypothetical scenarios
+- Do not add features or "improvements" beyond what was requested
+- Run linters and tests after making changes<% if (commands.lint) { %> (`<%= commands.lint %>`)<% } %><% if (commands.test) { %> (`<%= commands.test %>`)<% } %>