feat(cli): doctor checks hooks config validity and installed skills

- hooks config check: reads the three settings.json candidates, warns on
  invalid JSON (with the offending path), counts configured event types;
  duplicate candidates (project inside home dir) deduped by resolved path
- skills check: counts SKILL.md skill dirs across .agents/.claude/
  .levelcode locations (project + home), NO_COLOR-friendly
- runDoctorChecks gains explicit {projectRoot, homeDir} overrides — tests
  must not rely on os.homedir() env pinning (it caches on first call)
- /bug idea dropped deliberately: /feedback already aliases /bug

Author: yethikrishna

cli/src/commands/bug-report.ts

@@ -0,0 +1,60 @@
+/**
+ * `/bug <description>` — opens a pre-filled GitHub issue with the
+ * environment context every bug report needs (version, platform, runtime)
+ * and nothing that could leak user code or paths.
+ */
+
+import { createRequire } from 'module'
+import os from 'os'
+
+const REPO = 'yethikrishna/levelcode'
+
+function loadVersion(): string {
+  try {
+    const require = createRequire(import.meta.url)
+    const pkg = require('../../package.json') as { version?: string }
+    return pkg.version ?? 'unknown'
+  } catch {
+    return 'unknown'
+  }
+}
+
+/** Environment lines shared by every report — safe for public issues. */
+export function bugEnvironmentLines(): string[] {
+  return [
+    `- LevelCode version: ${loadVersion()}`,
+    `- Platform: ${process.platform} ${process.arch}`,
+    `- Runtime: ${process.versions.bun ? `bun ${process.versions.bun}` : `node ${process.versions.node ?? 'unknown'}`}`,
+    `- Mode: interactive CLI`,
+    `- Date: ${new Date().toISOString().slice(0, 10)}`,
+    `- Home dir name: ${os.homedir().split(/[\\/]/).pop() ? '(redacted)' : '(unknown)'}`,
+  ]
+}
+
+export function buildBugReportBody(description: string): string {
+  return [
+    '**What happened?**',
+    '',
+    description || '<describe the bug>',
+    '',
+    '**Steps to reproduce**',
+    '',
+    '1. ',
+    '',
+    '**Expected behavior**',
+    '',
+    '<what should have happened>',
+    '',
+    '**Environment**',
+    '',
+    ...bugEnvironmentLines(),
+  ].join('\n')
+}
+
+export function buildBugReportUrl(description: string): string {
+  const params = new URLSearchParams({
+    title: (description || 'Bug report').slice(0, 120),
+    body: buildBugReportBody(description),
+  })
+  return `https://github.com/${REPO}/issues/new?${params.toString()}`
+}

cli/src/doctor/__tests__/doctor.test.ts

@@ -1,10 +1,79 @@
-import { describe, it, expect } from 'bun:test'
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
 
 import {
   runDoctorChecks,
   formatDoctorReport,
   doctorExitCode,
 } from '../../doctor/doctor'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+
+describe('doctor hooks/skills checks', () => {
+  // Explicit overrides: os.homedir() caches on first call, so tests must not
+  // rely on env pinning — they pass projectRoot/homeDir directly.
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'doctor-fixtures-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('reports none-configured hooks and skills on a bare project', () => {
+    const checks = runDoctorChecks({ projectRoot: tmpDir, homeDir: tmpDir })
+    const hooks = checks.find((c) => c.name === 'hooks config')!
+    const skills = checks.find((c) => c.name === 'skills')!
+    expect(hooks.status).toBe('ok')
+    expect(hooks.detail).toContain('none configured')
+    expect(skills.status).toBe('ok')
+    expect(skills.detail).toContain('none installed')
+  })
+
+  it('warns on invalid JSON in a hooks-bearing settings file', () => {
+    fs.mkdirSync(path.join(tmpDir, '.levelcode'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.levelcode', 'settings.json'),
+      '{"hooks": { "PreToolUse": [ BROKEN',
+      'utf-8',
+    )
+    const checks = runDoctorChecks({ projectRoot: tmpDir, homeDir: tmpDir })
+    const hooks = checks.find((c) => c.name === 'hooks config')!
+    expect(hooks.status).toBe('warn')
+    expect(hooks.hint).toContain('settings.json')
+  })
+
+  it('counts configured hooks and installed skills', () => {
+    fs.mkdirSync(path.join(tmpDir, '.levelcode'), { recursive: true })
+    fs.writeFileSync(
+      path.join(tmpDir, '.levelcode', 'settings.json'),
+      JSON.stringify({
+        hooks: {
+          PreToolUse: [{ hooks: [{ command: 'exit 0' }] }],
+          Stop: [{ hooks: [{ command: 'exit 0' }] }],
+        },
+      }),
+      'utf-8',
+    )
+    const skillDir = path.join(tmpDir, '.agents', 'skills', 'my-skill')
+    fs.mkdirSync(skillDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(skillDir, 'SKILL.md'),
+      ['---', 'name: my-skill', 'description: test', '---', 'body'].join(
+        String.fromCharCode(10),
+      ),
+      'utf-8',
+    )
+
+    const checks = runDoctorChecks({ projectRoot: tmpDir, homeDir: tmpDir })
+    const hooks = checks.find((c) => c.name === 'hooks config')!
+    const skills = checks.find((c) => c.name === 'skills')!
+    expect(hooks.detail).toContain('2 event type(s)')
+    expect(skills.detail).toContain('1 skill(s)')
+  })
+})
 
 describe('doctor', () => {
   describe('runDoctorChecks', () => {
@@ -24,6 +93,8 @@ describe('doctor', () => {
       expect(names).toContain('runtime')
       expect(names).toContain('Model provider credentials')
       expect(names).toContain('config directory')
+      expect(names).toContain('hooks config')
+      expect(names).toContain('skills')
     })
   })
 

cli/src/doctor/doctor.ts

@@ -83,10 +83,11 @@ function checkRipgrep(): Check {
   }
 }
 
-function checkGit(): Check {
-  const inRepo = fs.existsSync(path.join(process.cwd(), '.git'))
+function checkGit(overrides: { projectRoot?: string } = {}): Check {
+  const root = overrides.projectRoot ?? process.cwd()
+  const inRepo = fs.existsSync(path.join(root, '.git'))
   if (inRepo) {
-    return { name: 'git repository', status: 'ok', detail: process.cwd() }
+    return { name: 'git repository', status: 'ok', detail: root }
   }
   return {
     name: 'git repository',
@@ -136,6 +137,149 @@ function checkNodeCompat(): Check {
   }
 }
 
+// ── Hooks & skills checks (syntax-level, dependency-light) ──────────────
+
+const SETTINGS_CANDIDATES = (projectRoot: string, homeDir?: string): string[] => {
+  const home = homeDir ?? os.homedir()
+  const envSuffix =
+    process.env.NEXT_PUBLIC_CB_ENVIRONMENT &&
+    process.env.NEXT_PUBLIC_CB_ENVIRONMENT !== 'prod'
+      ? `-${process.env.NEXT_PUBLIC_CB_ENVIRONMENT}`
+      : ''
+  const levelcodeBase =
+    process.env.LEVELCODE_DIR || path.join(home, '.levelcode')
+  return [
+    path.join(home, '.config', `levelcode${envSuffix}`, 'settings.json'),
+    path.join(levelcodeBase, 'settings.json'),
+    path.join(projectRoot, '.levelcode', 'settings.json'),
+  ]
+}
+
+export type HooksCheckOverrides = { projectRoot?: string; homeDir?: string }
+
+function checkHooksConfig(overrides: HooksCheckOverrides = {}): Check {
+  const projectRoot = overrides.projectRoot ?? process.cwd()
+  // Dedupe by resolved path: when the project lives inside the home dir,
+  // several candidates can resolve to the same settings file.
+  const seen = new Set<string>()
+  const candidates = SETTINGS_CANDIDATES(projectRoot, overrides.homeDir).filter((candidate) => {
+    const resolved = path.resolve(candidate)
+    if (seen.has(resolved)) return false
+    seen.add(resolved)
+    return true
+  })
+
+  let configured = 0
+  const problems: string[] = []
+
+  for (const candidate of candidates) {
+    let raw: string
+    try {
+      raw = fs.readFileSync(candidate, 'utf-8')
+    } catch {
+      continue
+    }
+    try {
+      const parsed: unknown = JSON.parse(raw)
+      const hooks =
+        parsed && typeof parsed === 'object' && 'hooks' in parsed
+          ? (parsed as { hooks?: unknown }).hooks
+          : undefined
+      if (hooks === undefined) continue
+      if (hooks && typeof hooks === 'object') {
+        configured += Object.keys(hooks as Record<string, unknown>).length
+      } else {
+        problems.push(candidate)
+      }
+    } catch {
+      problems.push(candidate)
+    }
+  }
+
+  if (problems.length > 0) {
+    return {
+      name: 'hooks config',
+      status: 'warn',
+      detail: `${problems.length} settings file(s) with invalid JSON`,
+      hint: `Fix or remove: ${problems[0]}${problems.length > 1 ? ` (+${problems.length - 1} more)` : ''}`,
+    }
+  }
+  if (configured === 0) {
+    return {
+      name: 'hooks config',
+      status: 'ok',
+      detail: 'none configured (see docs/hooks.md)',
+    }
+  }
+  return {
+    name: 'hooks config',
+    status: 'ok',
+    detail: `${configured} event type(s) configured`,
+  }
+}
+
+const SKILLS_DIRS = (projectRoot: string, homeDir: string): string[] => [
+  path.join(projectRoot, '.agents', 'skills'),
+  path.join(projectRoot, '.claude', 'skills'),
+  path.join(projectRoot, '.levelcode', 'skills'),
+  path.join(homeDir, '.claude', 'skills'),
+  path.join(homeDir, '.agents', 'skills'),
+  path.join(homeDir, '.config', 'levelcode', 'skills'),
+  path.join(homeDir, '.levelcode', 'skills'),
+]
+
+function countSkillsIn(dir: string): number {
+  try {
+    return fs
+      .readdirSync(dir, { withFileTypes: true })
+      .filter(
+        (e) => e.isDirectory() && fs.existsSync(path.join(dir, e.name, 'SKILL.md')),
+      ).length
+  } catch {
+    return 0
+  }
+}
+
+export type SkillsCheckOverrides = { projectRoot?: string; homeDir?: string }
+
+function checkSkills(overrides: SkillsCheckOverrides = {}): Check {
+  const projectRoot = overrides.projectRoot ?? process.cwd()
+  const homeDir = overrides.homeDir ?? os.homedir()
+
+  // Dedupe by resolved path: project and home lists overlap when the
+  // project lives inside the home directory.
+  const seen = new Set<string>()
+  const uniqueDirs = SKILLS_DIRS(projectRoot, homeDir).filter((dir) => {
+    const resolved = path.resolve(dir)
+    if (seen.has(resolved)) return false
+    seen.add(resolved)
+    return true
+  })
+
+  let total = 0
+  const sources: string[] = []
+  for (const dir of uniqueDirs) {
+    const n = countSkillsIn(dir)
+    if (n > 0) {
+      total += n
+      sources.push(dir)
+    }
+  }
+
+  if (total === 0) {
+    return {
+      name: 'skills',
+      status: 'ok',
+      detail: 'none installed (.agents/skills/<name>/SKILL.md)',
+    }
+  }
+  return {
+    name: 'skills',
+    status: 'ok',
+    detail: `${total} skill(s) in ${sources.length} location(s)`,
+  }
+}
+
 function checkSandboxSupport(): Check {
   if (process.platform === 'darwin') {
     return { name: 'sandbox (Seatbelt)', status: 'ok', detail: 'macOS sandbox-exec available' }
@@ -158,13 +302,20 @@ function checkSandboxSupport(): Check {
   return { name: 'sandbox', status: 'warn', detail: `unknown platform ${process.platform}` }
 }
 
-export function runDoctorChecks(): Check[] {
+export type DoctorCheckOverrides = {
+  projectRoot?: string
+  homeDir?: string
+}
+
+export function runDoctorChecks(overrides: DoctorCheckOverrides = {}): Check[] {
   return [
     checkNodeCompat(),
     checkProviderKeys(),
     checkConfigDir(),
+    checkHooksConfig(overrides),
+    checkSkills(overrides),
     checkRipgrep(),
-    checkGit(),
+    checkGit(overrides),
     checkSandboxSupport(),
   ]
 }