@pyreon/cli 0.5.0

package/src/context.ts

@@ -0,0 +1,327 @@
+/**
+ * pyreon context — generates .pyreon/context.json for AI tool consumption
+ *
+ * Scans the project to extract:
+ *  - Route definitions (paths, params, loaders, guards)
+ *  - Component inventory (file, props, signals)
+ *  - Island declarations (name, hydration strategy)
+ *  - Framework version
+ */
+
+import * as fs from "node:fs"
+import * as path from "node:path"
+
+export interface ContextOptions {
+  cwd: string
+  outPath?: string | undefined
+}
+
+export interface RouteInfo {
+  path: string
+  name?: string | undefined
+  component?: string | undefined
+  hasLoader: boolean
+  hasGuard: boolean
+  params: string[]
+  children?: RouteInfo[] | undefined
+}
+
+export interface ComponentInfo {
+  name: string
+  file: string
+  hasSignals: boolean
+  signalNames: string[]
+  props: string[]
+}
+
+export interface IslandInfo {
+  name: string
+  file: string
+  hydrate: string
+}
+
+export interface ProjectContext {
+  framework: "pyreon"
+  version: string
+  generatedAt: string
+  routes: RouteInfo[]
+  components: ComponentInfo[]
+  islands: IslandInfo[]
+}
+
+export async function generateContext(options: ContextOptions): Promise<ProjectContext> {
+  const version = readVersion(options.cwd)
+  const sourceFiles = collectTsxFiles(options.cwd)
+
+  const routes = extractRoutes(sourceFiles, options.cwd)
+  const components = extractComponents(sourceFiles, options.cwd)
+  const islands = extractIslands(sourceFiles, options.cwd)
+
+  const context: ProjectContext = {
+    framework: "pyreon",
+    version,
+    generatedAt: new Date().toISOString(),
+    routes,
+    components,
+    islands,
+  }
+
+  // Write to .pyreon/context.json
+  const outDir = options.outPath ? path.dirname(options.outPath) : path.join(options.cwd, ".pyreon")
+  const outFile = options.outPath ?? path.join(outDir, "context.json")
+
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true })
+  }
+  fs.writeFileSync(outFile, JSON.stringify(context, null, 2), "utf-8")
+
+  // Ensure .pyreon/ is in .gitignore
+  ensureGitignore(options.cwd)
+
+  const relOut = path.relative(options.cwd, outFile)
+  console.log(
+    `  ✓ Generated ${relOut} (${components.length} components, ${routes.length} routes, ${islands.length} islands)`,
+  )
+
+  return context
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Extractors
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseRouteFromBlock(block: string, routeMatch: RegExpExecArray): RouteInfo {
+  const routePath = routeMatch[1] ?? ""
+  const params = extractParams(routePath)
+
+  const surroundingStart = Math.max(0, routeMatch.index - 50)
+  const surroundingEnd = Math.min(block.length, routeMatch.index + 200)
+  const surrounding = block.slice(surroundingStart, surroundingEnd)
+
+  const hasLoader = /loader\s*:/.test(surrounding)
+  const hasGuard = /beforeEnter\s*:|beforeLeave\s*:/.test(surrounding)
+  const nameMatch = surrounding.match(/name\s*:\s*["']([^"']+)["']/)
+
+  return {
+    path: routePath,
+    name: nameMatch?.[1],
+    hasLoader,
+    hasGuard,
+    params,
+  }
+}
+
+function extractRoutesFromBlock(block: string): RouteInfo[] {
+  const routes: RouteInfo[] = []
+  const routeObjRe = /path\s*:\s*["']([^"']+)["']/g
+  let routeMatch: RegExpExecArray | null
+  while (true) {
+    routeMatch = routeObjRe.exec(block)
+    if (!routeMatch) break
+    routes.push(parseRouteFromBlock(block, routeMatch))
+  }
+  return routes
+}
+
+function extractRoutes(files: string[], _cwd: string): RouteInfo[] {
+  const routes: RouteInfo[] = []
+
+  for (const file of files) {
+    let code: string
+    try {
+      code = fs.readFileSync(file, "utf-8")
+    } catch {
+      continue
+    }
+
+    const routeArrayRe =
+      /(?:createRouter\s*\(\s*\[|(?:const|let)\s+routes\s*(?::\s*RouteRecord\[\])?\s*=\s*\[)([\s\S]*?)\]/g
+    let match: RegExpExecArray | null
+    while (true) {
+      match = routeArrayRe.exec(code)
+      if (!match) break
+      const block = match[1] ?? ""
+      for (const route of extractRoutesFromBlock(block)) {
+        routes.push(route)
+      }
+    }
+  }
+
+  return routes
+}
+
+function parseProps(propsStr: string): string[] {
+  return propsStr
+    .split(",")
+    .map((p) => p.trim().split(":")[0]?.split("=")[0]?.trim() ?? "")
+    .filter((p) => p && p !== "props")
+}
+
+function collectSignalNames(body: string): string[] {
+  const signalNames: string[] = []
+  const signalRe = /(?:const|let)\s+(\w+)\s*=\s*signal\s*[<(]/g
+  let sigMatch: RegExpExecArray | null
+  while (true) {
+    sigMatch = signalRe.exec(body)
+    if (!sigMatch) break
+    if (sigMatch[1]) signalNames.push(sigMatch[1])
+  }
+  return signalNames
+}
+
+function extractComponentsFromCode(code: string, relFile: string): ComponentInfo[] {
+  const components: ComponentInfo[] = []
+  const componentRe =
+    /(?:export\s+)?(?:const|function)\s+([A-Z]\w*)\s*(?::\s*ComponentFn<[^>]+>\s*)?=?\s*\(?(?:\s*\{?\s*([^)]*?)\s*\}?\s*)?\)?\s*(?:=>|{)/g
+  let match: RegExpExecArray | null
+
+  while (true) {
+    match = componentRe.exec(code)
+    if (!match) break
+    const name = match[1] ?? "Unknown"
+    const props = parseProps(match[2] ?? "")
+
+    const bodyStart = match.index + match[0].length
+    const body = code.slice(bodyStart, Math.min(code.length, bodyStart + 2000))
+    const signalNames = collectSignalNames(body)
+
+    components.push({
+      name,
+      file: relFile,
+      hasSignals: signalNames.length > 0,
+      signalNames,
+      props,
+    })
+  }
+
+  return components
+}
+
+function extractComponents(files: string[], _cwd: string): ComponentInfo[] {
+  const components: ComponentInfo[] = []
+
+  for (const file of files) {
+    let code: string
+    try {
+      code = fs.readFileSync(file, "utf-8")
+    } catch {
+      continue
+    }
+
+    const relFile = path.relative(_cwd, file)
+    for (const comp of extractComponentsFromCode(code, relFile)) {
+      components.push(comp)
+    }
+  }
+
+  return components
+}
+
+function extractIslands(files: string[], cwd: string): IslandInfo[] {
+  const islands: IslandInfo[] = []
+
+  for (const file of files) {
+    let code: string
+    try {
+      code = fs.readFileSync(file, "utf-8")
+    } catch {
+      continue
+    }
+
+    const islandRe =
+      /island\s*\(\s*\(\)\s*=>\s*import\(.+?\)\s*,\s*\{[^}]*name\s*:\s*["']([^"']+)["'][^}]*?(?:hydrate\s*:\s*["']([^"']+)["'])?[^}]*\}/g
+    let match: RegExpExecArray | null
+    while (true) {
+      match = islandRe.exec(code)
+      if (!match) break
+      if (match[1]) {
+        islands.push({
+          name: match[1],
+          file: path.relative(cwd, file),
+          hydrate: match[2] ?? "load",
+        })
+      }
+    }
+  }
+
+  return islands
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function extractParams(routePath: string): string[] {
+  const params: string[] = []
+  const paramRe = /:(\w+)\??/g
+  let match: RegExpExecArray | null
+  while (true) {
+    match = paramRe.exec(routePath)
+    if (!match) break
+    if (match[1]) params.push(match[1])
+  }
+  return params
+}
+
+function readVersion(cwd: string): string {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"))
+    const deps: Record<string, unknown> = { ...pkg.dependencies, ...pkg.devDependencies }
+    for (const [name, version] of Object.entries(deps)) {
+      if (name.startsWith("@pyreon/") && typeof version === "string") {
+        return version.replace(/^[\^~]/, "")
+      }
+    }
+    return (pkg.version as string) || "unknown"
+  } catch {
+    return "unknown"
+  }
+}
+
+const tsxExtensions = new Set([".tsx", ".jsx", ".ts", ".js"])
+const tsxIgnoreDirs = new Set(["node_modules", "dist", "lib", ".pyreon", ".git", "build"])
+
+function shouldSkipEntry(entry: fs.Dirent): boolean {
+  if (!entry.isDirectory()) return false
+  return entry.name.startsWith(".") || tsxIgnoreDirs.has(entry.name)
+}
+
+function walkTsxFiles(dir: string, results: string[]): void {
+  let entries: fs.Dirent[]
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return
+  }
+
+  for (const entry of entries) {
+    if (shouldSkipEntry(entry)) continue
+
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      walkTsxFiles(fullPath, results)
+    } else if (entry.isFile() && tsxExtensions.has(path.extname(entry.name))) {
+      results.push(fullPath)
+    }
+  }
+}
+
+function collectTsxFiles(cwd: string): string[] {
+  const results: string[] = []
+  walkTsxFiles(cwd, results)
+  return results
+}
+
+function ensureGitignore(cwd: string): void {
+  const gitignorePath = path.join(cwd, ".gitignore")
+  try {
+    const content = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf-8") : ""
+
+    if (!content.includes(".pyreon/") && !content.includes(".pyreon\n")) {
+      const addition = content.endsWith("\n") ? ".pyreon/\n" : "\n.pyreon/\n"
+      fs.appendFileSync(gitignorePath, addition)
+    }
+  } catch {
+    // Ignore errors with .gitignore
+  }
+}

package/src/doctor.ts

@@ -0,0 +1,251 @@
+/**
+ * pyreon doctor — project-wide health check for AI-friendly development
+ *
+ * Runs a pipeline of checks:
+ *  1. React pattern detection (imports, hooks, JSX attributes)
+ *  2. Import source validation (@pyreon/* vs react/vue)
+ *  3. Common Pyreon mistakes (signal without call, key vs by, etc.)
+ *
+ * Output modes:
+ *  - Human-readable (default): colored terminal output
+ *  - JSON (--json): structured output for AI agent consumption
+ *  - CI (--ci): exits with code 1 on any error
+ *
+ * Fix mode (--fix): auto-applies safe transforms via migrateReactCode
+ */
+
+import * as fs from "node:fs"
+import * as path from "node:path"
+import {
+  detectReactPatterns,
+  hasReactPatterns,
+  migrateReactCode,
+  type ReactDiagnostic,
+} from "@pyreon/compiler"
+
+export interface DoctorOptions {
+  fix: boolean
+  json: boolean
+  ci: boolean
+  cwd: string
+}
+
+interface FileResult {
+  file: string
+  diagnostics: ReactDiagnostic[]
+  fixed: boolean
+}
+
+interface DoctorResult {
+  passed: boolean
+  files: FileResult[]
+  summary: {
+    filesScanned: number
+    filesWithIssues: number
+    totalErrors: number
+    totalFixable: number
+    totalFixed: number
+  }
+}
+
+export async function doctor(options: DoctorOptions): Promise<number> {
+  const startTime = performance.now()
+  const files = collectSourceFiles(options.cwd)
+  const result = runChecks(files, options)
+  const elapsed = Math.round(performance.now() - startTime)
+
+  if (options.json) {
+    printJson(result)
+  } else {
+    printHuman(result, elapsed)
+  }
+
+  return result.summary.totalErrors
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// File collection
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const sourceExtensions = new Set([".tsx", ".jsx", ".ts", ".js"])
+const sourceIgnoreDirs = new Set([
+  "node_modules",
+  "dist",
+  "lib",
+  ".pyreon",
+  ".git",
+  ".next",
+  "build",
+])
+
+function shouldSkipDirEntry(entry: fs.Dirent): boolean {
+  if (!entry.isDirectory()) return false
+  return entry.name.startsWith(".") || sourceIgnoreDirs.has(entry.name)
+}
+
+function walkSourceFiles(dir: string, results: string[]): void {
+  let entries: fs.Dirent[]
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return
+  }
+
+  for (const entry of entries) {
+    if (shouldSkipDirEntry(entry)) continue
+
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      walkSourceFiles(fullPath, results)
+    } else if (entry.isFile() && sourceExtensions.has(path.extname(entry.name))) {
+      results.push(fullPath)
+    }
+  }
+}
+
+function collectSourceFiles(cwd: string): string[] {
+  const results: string[] = []
+  walkSourceFiles(cwd, results)
+  return results
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Check pipeline
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function checkFileWithFix(
+  file: string,
+  relPath: string,
+): { result: FileResult | null; fixCount: number } {
+  let code: string
+  try {
+    code = fs.readFileSync(file, "utf-8")
+  } catch {
+    return { result: null, fixCount: 0 }
+  }
+
+  if (!hasReactPatterns(code)) return { result: null, fixCount: 0 }
+
+  const migrated = migrateReactCode(code, relPath)
+  if (migrated.changes.length > 0) {
+    fs.writeFileSync(file, migrated.code, "utf-8")
+  }
+  const remaining = detectReactPatterns(migrated.code, relPath)
+  if (remaining.length > 0 || migrated.changes.length > 0) {
+    return {
+      result: { file: relPath, diagnostics: remaining, fixed: migrated.changes.length > 0 },
+      fixCount: migrated.changes.length,
+    }
+  }
+  return { result: null, fixCount: 0 }
+}
+
+function checkFileDetectOnly(file: string, relPath: string): FileResult | null {
+  let code: string
+  try {
+    code = fs.readFileSync(file, "utf-8")
+  } catch {
+    return null
+  }
+
+  if (!hasReactPatterns(code)) return null
+
+  const diagnostics = detectReactPatterns(code, relPath)
+  if (diagnostics.length > 0) {
+    return { file: relPath, diagnostics, fixed: false }
+  }
+  return null
+}
+
+function runChecks(files: string[], options: DoctorOptions): DoctorResult {
+  const fileResults: FileResult[] = []
+  let totalFixed = 0
+
+  for (const file of files) {
+    const relPath = path.relative(options.cwd, file)
+
+    if (options.fix) {
+      const { result, fixCount } = checkFileWithFix(file, relPath)
+      totalFixed += fixCount
+      if (result) fileResults.push(result)
+    } else {
+      const result = checkFileDetectOnly(file, relPath)
+      if (result) fileResults.push(result)
+    }
+  }
+
+  const totalErrors = fileResults.reduce((sum, f) => sum + f.diagnostics.length, 0)
+  const totalFixable = fileResults.reduce(
+    (sum, f) => sum + f.diagnostics.filter((d) => d.fixable).length,
+    0,
+  )
+
+  return {
+    passed: totalErrors === 0,
+    files: fileResults,
+    summary: {
+      filesScanned: files.length,
+      filesWithIssues: fileResults.length,
+      totalErrors,
+      totalFixable,
+      totalFixed,
+    },
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Output formatters
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printJson(result: DoctorResult): void {
+  console.log(JSON.stringify(result, null, 2))
+}
+
+function printFileResult(fileResult: FileResult): void {
+  if (fileResult.diagnostics.length === 0) return
+
+  console.log(`  ${fileResult.file}${fileResult.fixed ? " (partially fixed)" : ""}`)
+
+  for (const diag of fileResult.diagnostics) {
+    const fixTag = diag.fixable ? " [fixable]" : ""
+    console.log(`    ${diag.line}:${diag.column} — ${diag.message}${fixTag}`)
+    console.log(`      Current:   ${diag.current}`)
+    console.log(`      Suggested: ${diag.suggested}`)
+    console.log("")
+  }
+}
+
+function printSummary(summary: DoctorResult["summary"]): void {
+  console.log(
+    `  ${summary.totalErrors} issue${summary.totalErrors === 1 ? "" : "s"} in ${summary.filesWithIssues} file${summary.filesWithIssues === 1 ? "" : "s"}`,
+  )
+  if (summary.totalFixable > 0) {
+    console.log(`  ${summary.totalFixable} auto-fixable — run 'pyreon doctor --fix' to apply`)
+  }
+  console.log("")
+}
+
+function printHuman(result: DoctorResult, elapsed: number): void {
+  const { summary } = result
+
+  console.log("")
+  console.log(`  Pyreon Doctor — scanned ${summary.filesScanned} files in ${elapsed}ms`)
+  console.log("")
+
+  if (result.passed && summary.totalFixed === 0) {
+    console.log("  ✓ No issues found. Your code is Pyreon-native!")
+    console.log("")
+    return
+  }
+
+  if (summary.totalFixed > 0) {
+    console.log(`  ✓ Auto-fixed ${summary.totalFixed} issue${summary.totalFixed === 1 ? "" : "s"}`)
+    console.log("")
+  }
+
+  for (const fileResult of result.files) {
+    printFileResult(fileResult)
+  }
+
+  printSummary(summary)
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ * @pyreon/cli — Developer tools for Pyreon
+ *
+ * Commands:
+ *   pyreon doctor [--fix] [--json]  — Scan project for React patterns, bad imports, etc.
+ *   pyreon context                  — Generate .pyreon/context.json for AI tools
+ */
+
+import { generateContext } from "./context"
+import { type DoctorOptions, doctor } from "./doctor"
+
+const args = process.argv.slice(2)
+const command = args[0]
+
+function printUsage(): void {
+  console.log(`
+  pyreon <command> [options]
+
+  Commands:
+    doctor [--fix] [--json] [--ci]   Scan for React patterns, bad imports, and common mistakes
+    context [--out <path>]           Generate .pyreon/context.json for AI tools
+
+  Options:
+    --help                           Show this help message
+    --version                        Show version
+`)
+}
+
+async function main(): Promise<void> {
+  if (!command || command === "--help" || command === "-h") {
+    printUsage()
+    return
+  }
+
+  if (command === "--version" || command === "-v") {
+    console.log("0.4.0")
+    return
+  }
+
+  if (command === "doctor") {
+    const options: DoctorOptions = {
+      fix: args.includes("--fix"),
+      json: args.includes("--json"),
+      ci: args.includes("--ci"),
+      cwd: process.cwd(),
+    }
+    const exitCode = await doctor(options)
+    if (options.ci && exitCode > 0) {
+      process.exit(1)
+    }
+    return
+  }
+
+  if (command === "context") {
+    const outIdx = args.indexOf("--out")
+    const outPath = outIdx >= 0 ? args[outIdx + 1] : undefined
+    await generateContext({ cwd: process.cwd(), outPath })
+    return
+  }
+
+  console.error(`Unknown command: ${command}`)
+  printUsage()
+  process.exit(1)
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})
+
+export type { ContextOptions, ProjectContext } from "./context"
+export type { DoctorOptions } from "./doctor"
+export { doctor, generateContext }