@ic-reactor/cli 0.4.1 → 0.5.0

package/schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "IC Reactor CLI Configuration",
-  "description": "Configuration file for @ic-reactor/cli",
+  "title": "IC Reactor Configuration",
+  "description": "Configuration file for @ic-reactor/cli and @ic-reactor/vite-plugin",
   "type": "object",
   "properties": {
     "$schema": {
@@ -10,8 +10,13 @@
     },
     "outDir": {
       "type": "string",
-      "description": "Output directory for generated hooks (relative to project root)",
-      "default": "src/canisters"
+      "description": "Default output directory for generated files (relative to project root)",
+      "default": "src/declarations"
+    },
+    "clientManagerPath": {
+      "type": "string",
+      "description": "Default import path for the client manager (relative from generated files)",
+      "default": "../../clients"
     },
     "canisters": {
       "type": "object",
@@ -19,58 +24,28 @@
       "additionalProperties": {
         "type": "object",
         "properties": {
+          "name": {
+            "type": "string",
+            "description": "Canister name (required)"
+          },
           "didFile": {
             "type": "string",
-            "description": "Path to the .did file (relative to project root)"
+            "description": "Path to the .did file (required)"
           },
-          "clientManagerPath": {
+          "outDir": {
             "type": "string",
-            "description": "Import path to the client manager (relative from generated hooks)",
-            "default": "../../lib/client"
+            "description": "Override output directory for this canister"
           },
-          "useDisplayReactor": {
-            "type": "boolean",
-            "description": "Use DisplayReactor for automatic type transformations (bigint → string, etc.)",
-            "default": true
+          "clientManagerPath": {
+            "type": "string",
+            "description": "Override client manager import path for this canister"
           },
           "canisterId": {
             "type": "string",
-            "description": "Optional fixed canister ID (defaults to environment-based resolution)"
+            "description": "Optional fixed canister ID"
           }
         },
-        "required": ["didFile"]
-      }
-    },
-    "generatedHooks": {
-      "type": "object",
-      "description": "Tracks which methods have generated hooks (managed by CLI)",
-      "additionalProperties": {
-        "items": {
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "object",
-              "properties": {
-                "name": {
-                  "type": "string"
-                },
-                "type": {
-                  "type": "string",
-                  "enum": [
-                    "query",
-                    "mutation",
-                    "suspenseQuery",
-                    "infiniteQuery",
-                    "suspenseInfiniteQuery"
-                  ]
-                }
-              },
-              "required": ["name"]
-            }
-          ]
-        }
+        "required": ["name", "didFile"]
       }
     }
   },

package/src/commands/generate.ts

@@ -0,0 +1,114 @@
+/**
+ * Generate Command
+ *
+ * Runs the codegen pipeline for configured canisters.
+ */
+
+import * as p from "@clack/prompts"
+import pc from "picocolors"
+import { loadConfig, findConfigFile, getProjectRoot } from "../utils/config.js"
+import { runCanisterPipeline } from "@ic-reactor/codegen"
+import type { GenerateOptions } from "../types.js"
+
+export async function generateCommand(options: GenerateOptions) {
+  console.log()
+  p.intro(pc.cyan("🔄 Generate Hooks"))
+
+  // Load config
+  const configPath = findConfigFile()
+  if (!configPath) {
+    p.log.error(
+      `No ${pc.yellow("ic-reactor.json")} found. Run ${pc.cyan("npx ic-reactor init")} first.`
+    )
+    process.exit(1)
+  }
+
+  const config = loadConfig(configPath)
+  if (!config) {
+    p.log.error(`Failed to load config from ${pc.yellow(configPath)}`)
+    process.exit(1)
+  }
+
+  const projectRoot = getProjectRoot()
+  const canisterNames = Object.keys(config.canisters)
+
+  if (canisterNames.length === 0) {
+    p.log.error("No canisters configured.")
+    process.exit(1)
+  }
+
+  // Determine which canisters to process
+  let canistersToProcess: string[] = []
+
+  if (options.canister) {
+    if (!config.canisters[options.canister]) {
+      p.log.error(
+        `Canister ${pc.yellow(options.canister)} not found in config.`
+      )
+      process.exit(1)
+    }
+    canistersToProcess = [options.canister]
+  } else {
+    canistersToProcess = canisterNames
+  }
+
+  const spinner = p.spinner()
+  spinner.start(
+    `Generating hooks for ${canistersToProcess.length} canisters...`
+  )
+
+  let successCount = 0
+  let errorCount = 0
+  const errorMessages: string[] = []
+
+  // Run pipeline for each canister
+  for (const name of canistersToProcess) {
+    const canisterConfig = config.canisters[name]
+
+    spinner.message(`Processing ${pc.cyan(name)}...`)
+
+    try {
+      const result = await runCanisterPipeline({
+        canisterConfig,
+        projectRoot,
+        globalConfig: config,
+      })
+
+      if (result.success) {
+        successCount++
+      } else {
+        errorCount++
+        errorMessages.push(`${name}: ${result.error}`)
+      }
+    } catch (err) {
+      errorCount++
+      errorMessages.push(
+        `${name}: ${err instanceof Error ? err.message : String(err)}`
+      )
+    }
+  }
+
+  spinner.stop("Generation complete")
+
+  if (errorMessages.length > 0) {
+    console.log()
+    p.log.error("Errors encountered:")
+    for (const msg of errorMessages) {
+      console.log(`  ${pc.red("•")} ${msg}`)
+    }
+  }
+
+  console.log()
+  p.note(
+    `Success: ${pc.green(successCount.toString())}\n` +
+      `Failed:  ${pc.red(errorCount.toString())}`,
+    "Summary"
+  )
+
+  if (errorCount > 0) {
+    p.outro(pc.red("✖ Generation failed with errors."))
+    process.exit(1)
+  } else {
+    p.outro(pc.green("✓ All hooks generated successfully!"))
+  }
+}

package/src/commands/init.ts

@@ -1,7 +1,7 @@
 /**
- * Init command
+ * Init Command
  *
- * Initializes ic-reactor configuration in the project.
+ * Initializes ic-reactor.json configuration.
  */
 
 import * as p from "@clack/prompts"
@@ -16,7 +16,8 @@ import {
   getProjectRoot,
   ensureDir,
 } from "../utils/config.js"
-import type { ReactorConfig, CanisterConfig } from "../types.js"
+import type { CodegenConfig, CanisterConfig } from "../types.js"
+import { generateClientFile } from "@ic-reactor/codegen"
 
 interface InitOptions {
   yes?: boolean
@@ -42,183 +43,115 @@ export async function initCommand(options: InitOptions) {
   }
 
   const projectRoot = getProjectRoot()
-  let config: ReactorConfig
+  let config: CodegenConfig
 
   if (options.yes) {
-    // Use defaults
     config = { ...DEFAULT_CONFIG }
     if (options.outDir) {
       config.outDir = options.outDir
     }
   } else {
-    // Interactive mode
+    // Interactive Setup
+
+    // Output Directory
     const outDir = await p.text({
-      message: "Where should generated hooks be placed?",
-      placeholder: "src/lib/canisters",
-      defaultValue: "src/lib/canisters",
-      validate: (value) => {
-        if (!value) return "Output directory is required"
-        return undefined
-      },
+      message: "Where should generated files be placed?",
+      placeholder: "src/declarations",
+      defaultValue: "src/declarations",
     })
+    if (p.isCancel(outDir)) process.exit(0)
 
-    if (p.isCancel(outDir)) {
-      p.cancel("Setup cancelled.")
-      process.exit(0)
-    }
-
-    // Ask if they want to add a canister now
-    const addCanister = await p.confirm({
-      message: "Would you like to add a canister now?",
-      initialValue: true,
+    // Client Manager Path
+    const clientManagerPath = await p.text({
+      message: "Relative path for the client manager import?",
+      placeholder: "../../clients",
+      defaultValue: "../../clients",
     })
-
-    if (p.isCancel(addCanister)) {
-      p.cancel("Setup cancelled.")
-      process.exit(0)
-    }
+    if (p.isCancel(clientManagerPath)) process.exit(0)
 
     config = {
       ...DEFAULT_CONFIG,
       outDir: outDir as string,
+      clientManagerPath: clientManagerPath as string,
     }
 
+    // Add initial canister?
+    const addCanister = await p.confirm({
+      message: "Would you like to configure a canister now?",
+      initialValue: true,
+    })
+    if (p.isCancel(addCanister)) process.exit(0)
+
     if (addCanister) {
-      const canisterInfo = await promptForCanister(projectRoot)
-      if (canisterInfo) {
-        config.canisters[canisterInfo.name] = canisterInfo.config
+      const canister = await promptForCanister(projectRoot)
+      if (canister) {
+        config.canisters[canister.name] = canister
       }
     }
   }
 
-  // Save config file
+  // Save config
   const configPath = path.join(projectRoot, CONFIG_FILE_NAME)
   saveConfig(config, configPath)
 
-  // Create output directory
-  const fullOutDir = path.join(projectRoot, config.outDir)
-  ensureDir(fullOutDir)
+  // Ensure directories exist
+  ensureDir(path.join(projectRoot, config.outDir))
+
+  // Create default Client Manager
+  const clientManagerFile = path.join(projectRoot, "src/clients.ts")
+  // Simple heuristic: if clientManagerPath is "../../clients", likely file is src/clients.ts
+  // Users can move it, but this gives a good start.
 
-  // Create a sample client manager if it doesn't exist
-  const clientManagerPath = path.join(projectRoot, "src/lib/clients.ts")
-  if (!fs.existsSync(clientManagerPath)) {
-    const createClient = await p.confirm({
-      message: "Create a sample client manager at src/lib/clients.ts?",
+  if (!fs.existsSync(clientManagerFile)) {
+    const createHelpers = await p.confirm({
+      message: `Create a default client manager at ${pc.green("src/clients.ts")}?`,
       initialValue: true,
     })
 
-    if (!p.isCancel(createClient) && createClient) {
-      ensureDir(path.dirname(clientManagerPath))
-      fs.writeFileSync(clientManagerPath, getClientManagerTemplate())
-      p.log.success(`Created ${pc.green("src/lib/clients.ts")}`)
+    if (createHelpers === true) {
+      ensureDir(path.dirname(clientManagerFile))
+      fs.writeFileSync(clientManagerFile, generateClientFile())
+      p.log.success(`Created ${pc.green("src/clients.ts")}`)
     }
   }
 
   p.log.success(`Created ${pc.green(CONFIG_FILE_NAME)}`)
-  p.log.success(`Created ${pc.green(config.outDir)} directory`)
 
   console.log()
   p.note(
-    `Next steps:
-  
-  1. ${pc.cyan("Add a canister:")}
-     ${pc.dim("npx @ic-reactor/cli add")}
-  
-  2. ${pc.cyan("List available methods:")}
-     ${pc.dim("npx @ic-reactor/cli list -c <canister-name>")}
-  
-  3. ${pc.cyan("Add hooks for specific methods:")}
-     ${pc.dim("npx @ic-reactor/cli add -c <canister> -m <method>")}`,
-    "Getting Started"
+    `To generate hooks, run:\n${pc.cyan("npx ic-reactor generate")}`,
+    "Next Steps"
   )
 
-  p.outro(pc.green("✓ ic-reactor initialized successfully!"))
+  p.outro(pc.green("✓ Setup complete!"))
 }
 
 async function promptForCanister(
   projectRoot: string
-): Promise<{ name: string; config: CanisterConfig } | null> {
+): Promise<CanisterConfig | null> {
   const name = await p.text({
     message: "Canister name",
     placeholder: "backend",
-    validate: (value) => {
-      if (!value) return "Canister name is required"
-      if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value)) {
-        return "Canister name must start with a letter and contain only letters, numbers, hyphens, and underscores"
-      }
-      return undefined
+    validate: (val) => {
+      if (!val) return "Name is required"
+      if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(val)) return "Invalid name format"
     },
   })
-
   if (p.isCancel(name)) return null
 
   const didFile = await p.text({
     message: "Path to .did file",
-    placeholder: "./backend.did",
-    validate: (value) => {
-      if (!value) return "DID file path is required"
-      const fullPath = path.resolve(projectRoot, value)
-      if (!fs.existsSync(fullPath)) {
-        return `File not found: ${value}`
-      }
-      return undefined
+    placeholder: "./src/backend/backend.did",
+    validate: (val) => {
+      if (!val) return "Path is required"
+      const fullPath = path.resolve(projectRoot, val)
+      if (!fs.existsSync(fullPath)) return `File not found: ${val}`
     },
   })
-
   if (p.isCancel(didFile)) return null
 
-  const clientManagerPath = await p.text({
-    message:
-      "Import path to your client manager (relative from generated hooks)",
-    placeholder: "../../clients",
-    defaultValue: "../../clients",
-  })
-
-  if (p.isCancel(clientManagerPath)) return null
-
-  const useDisplayReactor = await p.confirm({
-    message:
-      "Use DisplayReactor? (auto-converts bigint → string, Principal → string)",
-    initialValue: true,
-  })
-
-  if (p.isCancel(useDisplayReactor)) return null
-
   return {
     name: name as string,
-    config: {
-      didFile: didFile as string,
-      clientManagerPath: clientManagerPath as string,
-      useDisplayReactor: useDisplayReactor as boolean,
-    },
+    didFile: didFile as string,
   }
 }
-
-function getClientManagerTemplate(): string {
-  return `/**
- * IC Client Manager
- *
- * This file configures the IC agent and client manager for your application.
- * Customize the agent options based on your environment.
- */
-
-import { ClientManager } from "@ic-reactor/react"
-
-/**
- * The client manager handles agent lifecycle and authentication.
- *
- * Configuration options:
- * - host: IC network host (defaults to process env or mainnet)
- * - identity: Initial identity (optional, can be set later)
- * - verifyQuerySignatures: Verify query signatures (recommended for production)
- *
- * For local development, the agent will automatically detect local replica.
- */
-export const clientManager = new ClientManager({
-  // Uncomment for explicit host configuration:
-  // host: process.env.DFX_NETWORK === "local"
-  //   ? "http://localhost:4943"
-  //   : "https://icp-api.io",
-})
-`
-}

package/src/index.ts

@@ -2,42 +2,35 @@
 /**
  * @ic-reactor/cli
  *
- * CLI tool to generate shadcn-style React hooks for ICP canisters.
- * Gives users full control over generated code - no magic, just scaffolding.
+ * CLI tool to generate type-safe React hooks for ICP canisters.
  */
 
 import { Command } from "commander"
 import { initCommand } from "./commands/init.js"
-import { syncCommand } from "./commands/sync.js"
-import { listCommand } from "./commands/list.js"
+import { generateCommand } from "./commands/generate.js"
 import pc from "picocolors"
+import { version } from "../package.json"
 
 const program = new Command()
 
 program
   .name("ic-reactor")
-  .description(
-    pc.cyan("🔧 Generate shadcn-style React hooks for ICP canisters")
-  )
-  .version("3.0.0")
+  .description(pc.cyan("🔧 Generate type-safe React hooks for ICP canisters"))
+  .version(version)
 
 program
   .command("init")
   .description("Initialize ic-reactor configuration in your project")
   .option("-y, --yes", "Skip prompts and use defaults")
-  .option("-o, --out-dir <path>", "Output directory for generated hooks")
+  .option("-o, --out-dir <path>", "Output directory for generated files")
   .action(initCommand)
 
 program
-  .command("sync")
-  .description("Sync hooks with .did file changes")
-  .option("-c, --canister <name>", "Canister to sync")
-  .action(syncCommand)
-
-program
-  .command("list")
-  .description("List available methods from a canister")
-  .option("-c, --canister <name>", "Canister to list methods from")
-  .action(listCommand)
+  .command("generate")
+  .alias("g")
+  .description("Generate hooks from .did files")
+  .option("-c, --canister <name>", "Generate for a specific canister only")
+  .option("--clean", "Clean output directory before generating")
+  .action(generateCommand)
 
 program.parse()

package/src/types.ts

@@ -1,26 +1,27 @@
 /**
  * CLI-specific Types
  *
- * Shared types (MethodInfo, CanisterConfig, HookType, GeneratorOptions)
- * are now in @ic-reactor/codegen.
+ * Most types are now imported from @ic-reactor/codegen to ensure consistency.
  */
 
-export type { CanisterConfig, HookType } from "@ic-reactor/codegen"
+import type { CodegenConfig, CanisterConfig } from "@ic-reactor/codegen"
 
-export interface HookConfig {
-  name: string
-  type?: HookType
+// Re-export for convenience
+export type { CodegenConfig, CanisterConfig }
+
+/**
+ * CLI arguments for the `init` command
+ */
+export interface InitOptions {
+  yes?: boolean
+  outDir?: string
+  dryRun?: boolean
 }
 
-export interface ReactorConfig {
-  /** Schema version */
-  $schema?: string
-  /** Output directory for generated files */
-  outDir: string
-  /** Default path to client manager import (can be overridden per canister) */
-  clientManagerPath?: string
-  /** Canister configurations */
-  canisters: Record<string, CanisterConfig>
-  /** Track which hooks have been generated */
-  generatedHooks: Record<string, Array<string | HookConfig>>
+/**
+ * CLI arguments for the `generate` command
+ */
+export interface GenerateOptions {
+  canister?: string
+  clean?: boolean
 }

package/src/utils/config.ts

@@ -4,16 +4,15 @@
 
 import fs from "node:fs"
 import path from "node:path"
-import type { ReactorConfig } from "../types.js"
+import type { CodegenConfig } from "../types.js"
 
 export const CONFIG_FILE_NAME = "ic-reactor.json"
 
-export const DEFAULT_CONFIG: ReactorConfig = {
+export const DEFAULT_CONFIG: CodegenConfig = {
   $schema:
     "https://raw.githubusercontent.com/B3Pay/ic-reactor/main/packages/cli/schema.json",
-  outDir: "src/lib/canisters",
+  outDir: "src/declarations",
   canisters: {},
-  generatedHooks: {},
 }
 
 /**
@@ -38,7 +37,7 @@ export function findConfigFile(
 /**
  * Load the reactor config file
  */
-export function loadConfig(configPath?: string): ReactorConfig | null {
+export function loadConfig(configPath?: string): CodegenConfig | null {
   const filePath = configPath ?? findConfigFile()
 
   if (!filePath || !fs.existsSync(filePath)) {
@@ -47,7 +46,7 @@ export function loadConfig(configPath?: string): ReactorConfig | null {
 
   try {
     const content = fs.readFileSync(filePath, "utf-8")
-    return JSON.parse(content) as ReactorConfig
+    return JSON.parse(content) as CodegenConfig
   } catch {
     return null
   }
@@ -57,7 +56,7 @@ export function loadConfig(configPath?: string): ReactorConfig | null {
  * Save the reactor config file
  */
 export function saveConfig(
-  config: ReactorConfig,
+  config: CodegenConfig,
   configPath: string = path.join(process.cwd(), CONFIG_FILE_NAME)
 ): void {
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n")
@@ -65,23 +64,12 @@ export function saveConfig(
 
 /**
  * Get the project root directory.
- *
- * Priority:
- * 1. Directory containing reactor.config.json (if found)
- * 2. Current working directory (default for new projects)
- *
- * Note: We intentionally don't traverse up looking for package.json
- * as this can cause issues when running in subdirectories or when
- * parent directories have their own package.json files.
  */
 export function getProjectRoot(): string {
-  // First, check if there's a reactor.config.json in the current directory or parents
   const configPath = findConfigFile()
   if (configPath) {
     return path.dirname(configPath)
   }
-
-  // Default to current working directory for new projects
   return process.cwd()
 }
 
@@ -94,19 +82,8 @@ export function ensureDir(dirPath: string): void {
   }
 }
 
-/**
- * Check if a file exists
- */
-export function fileExists(filePath: string): boolean {
-  return fs.existsSync(filePath)
-}
-
-/**
- * Calculate relative path from one file to another
- */
 export function getRelativePath(from: string, to: string): string {
   const relativePath = path.relative(path.dirname(from), to)
-  // Ensure it starts with ./ or ../
   if (!relativePath.startsWith(".")) {
     return "./" + relativePath
   }