@ic-reactor/cli 0.0.0-dev3 → 0.2.0

package/src/generators/query.ts

@@ -0,0 +1,32 @@
+/**
+ * Query hook generator
+ *
+ * Generates createQuery-based hooks for canister query methods.
+ */
+
+import {
+  type MethodInfo,
+  type HookType,
+  generateQueryHook as generateQueryHookFromCodegen,
+} from "@ic-reactor/codegen"
+import type { ReactorConfig } from "../types.js"
+
+export interface QueryHookOptions {
+  canisterName: string
+  method: MethodInfo
+  config: ReactorConfig // Not used by codegen but kept for CLI consistency if needed
+  type?: HookType
+}
+
+/**
+ * Generate a query hook file content
+ */
+export function generateQueryHook(options: QueryHookOptions): string {
+  const { canisterName, method, type } = options
+
+  return generateQueryHookFromCodegen({
+    canisterName,
+    method,
+    type,
+  })
+}

package/src/generators/reactor.ts

@@ -0,0 +1,41 @@
+/**
+ * Reactor file generator
+ *
+ * Generates the shared reactor instance file for a canister.
+ */
+
+import {
+  type CanisterConfig,
+  generateReactorFile as generateReactorFileFromCodegen,
+} from "@ic-reactor/codegen"
+import type { ReactorConfig } from "../types.js"
+
+export interface ReactorGeneratorOptions {
+  canisterName: string
+  canisterConfig: CanisterConfig
+  config: ReactorConfig
+  outDir: string
+  hasDeclarations?: boolean
+}
+
+/**
+ * Generate the reactor.ts file content
+ */
+export function generateReactorFile(options: ReactorGeneratorOptions): string {
+  const {
+    canisterName,
+    canisterConfig,
+    config,
+    hasDeclarations = true,
+  } = options
+
+  return generateReactorFileFromCodegen({
+    canisterName,
+    canisterConfig,
+    hasDeclarations,
+    globalClientManagerPath: config.clientManagerPath,
+    // CLI doesn't currently expose advanced mode per-canister, but we default to false (simple mode)
+    // If we want to support it, we'd add 'advanced' to CanisterConfig or ReactorGeneratorOptions
+    advanced: false,
+  })
+}

package/src/index.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * @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.
+ */
+
+import { Command } from "commander"
+import { initCommand } from "./commands/init.js"
+import { addCommand } from "./commands/add.js"
+import { syncCommand } from "./commands/sync.js"
+import { listCommand } from "./commands/list.js"
+import { fetchCommand } from "./commands/fetch.js"
+import pc from "picocolors"
+
+const program = new Command()
+
+program
+  .name("ic-reactor")
+  .description(
+    pc.cyan("🔧 Generate shadcn-style React hooks for ICP canisters")
+  )
+  .version("3.0.0")
+
+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")
+  .action(initCommand)
+
+program
+  .command("add")
+  .description("Add hooks for canister methods (from local .did file)")
+  .option("-c, --canister <name>", "Canister name to add hooks for")
+  .option("-m, --methods <methods...>", "Method names to generate hooks for")
+  .option("-a, --all", "Add hooks for all methods")
+  .action(addCommand)
+
+program
+  .command("fetch")
+  .description("Fetch Candid from a live canister and generate hooks")
+  .option("-i, --canister-id <id>", "Canister ID to fetch from")
+  .option("-n, --network <network>", "Network: 'ic' or 'local'", "ic")
+  .option("--name <name>", "Name for the canister in generated code")
+  .option("-m, --methods <methods...>", "Method names to generate hooks for")
+  .option("-a, --all", "Add hooks for all methods")
+  .action(fetchCommand)
+
+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)
+
+program.parse()

package/src/types.ts

@@ -0,0 +1,26 @@
+/**
+ * CLI-specific Types
+ *
+ * Shared types (MethodInfo, CanisterConfig, HookType, GeneratorOptions)
+ * are now in @ic-reactor/codegen.
+ */
+
+import type { CanisterConfig, HookType } from "@ic-reactor/codegen"
+
+export interface HookConfig {
+  name: string
+  type?: HookType
+}
+
+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>>
+}

package/src/utils/config.ts

@@ -0,0 +1,114 @@
+/**
+ * Configuration file utilities
+ */
+
+import fs from "node:fs"
+import path from "node:path"
+import type { ReactorConfig } from "../types.js"
+
+export const CONFIG_FILE_NAME = "reactor.config.json"
+
+export const DEFAULT_CONFIG: ReactorConfig = {
+  $schema:
+    "https://raw.githubusercontent.com/B3Pay/ic-reactor/main/packages/cli/schema.json",
+  outDir: "src/canisters",
+  canisters: {},
+  generatedHooks: {},
+}
+
+/**
+ * Find the config file in the current directory or parent directories
+ */
+export function findConfigFile(
+  startDir: string = process.cwd()
+): string | null {
+  let currentDir = startDir
+
+  while (currentDir !== path.dirname(currentDir)) {
+    const configPath = path.join(currentDir, CONFIG_FILE_NAME)
+    if (fs.existsSync(configPath)) {
+      return configPath
+    }
+    currentDir = path.dirname(currentDir)
+  }
+
+  return null
+}
+
+/**
+ * Load the reactor config file
+ */
+export function loadConfig(configPath?: string): ReactorConfig | null {
+  const filePath = configPath ?? findConfigFile()
+
+  if (!filePath || !fs.existsSync(filePath)) {
+    return null
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, "utf-8")
+    return JSON.parse(content) as ReactorConfig
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Save the reactor config file
+ */
+export function saveConfig(
+  config: ReactorConfig,
+  configPath: string = path.join(process.cwd(), CONFIG_FILE_NAME)
+): void {
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n")
+}
+
+/**
+ * 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()
+}
+
+/**
+ * Ensure a directory exists
+ */
+export function ensureDir(dirPath: string): void {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true })
+  }
+}
+
+/**
+ * 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
+  }
+  return relativePath
+}

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Utils barrel export
+ */
+
+export * from "./config.js"
+export * from "./network.js"

package/src/utils/network.ts

@@ -0,0 +1,139 @@
+/**
+ * IC Network utilities
+ *
+ * Fetches Candid interfaces from live canisters on the IC network.
+ */
+
+import { HttpAgent, Actor } from "@icp-sdk/core/agent"
+import { Principal } from "@icp-sdk/core/principal"
+import { IDL } from "@icp-sdk/core/candid"
+import type { MethodInfo } from "@ic-reactor/codegen"
+import { extractMethods } from "@ic-reactor/codegen"
+
+// IC mainnet host
+const IC_HOST = "https://icp-api.io"
+
+// Local replica host
+const LOCAL_HOST = "http://127.0.0.1:4943"
+
+export type NetworkType = "ic" | "local"
+
+export interface FetchCandidOptions {
+  canisterId: string
+  network?: NetworkType
+  host?: string
+}
+
+export interface CandidResult {
+  candidSource: string
+  methods: MethodInfo[]
+  canisterId: string
+  network: NetworkType
+}
+
+/**
+ * Fetch Candid interface from a live canister
+ *
+ * Uses the `__get_candid_interface_tmp_hack` method which is available
+ * on most canisters that were compiled with candid export.
+ */
+export async function fetchCandidFromCanister(
+  options: FetchCandidOptions
+): Promise<CandidResult> {
+  const { canisterId, network = "ic", host } = options
+
+  // Validate canister ID
+  let principal: Principal
+  try {
+    principal = Principal.fromText(canisterId)
+  } catch {
+    throw new Error(`Invalid canister ID: ${canisterId}`)
+  }
+
+  // Determine host
+  const agentHost = host ?? (network === "local" ? LOCAL_HOST : IC_HOST)
+
+  // Create agent
+  const agent = await HttpAgent.create({
+    host: agentHost,
+    // Don't verify signatures for CLI queries
+    verifyQuerySignatures: false,
+  })
+
+  // For local network, fetch root key (unsafe for mainnet)
+  if (network === "local") {
+    try {
+      await agent.fetchRootKey()
+    } catch {
+      throw new Error(
+        `Failed to connect to local replica at ${agentHost}. Is it running?`
+      )
+    }
+  }
+
+  // Try to fetch Candid interface using the temporary hack method
+  // This method is added by the Rust CDK and Motoko compiler
+  const candidInterface = IDL.Service({
+    __get_candid_interface_tmp_hack: IDL.Func([], [IDL.Text], ["query"]),
+  })
+
+  const actor = Actor.createActor(() => candidInterface, {
+    agent,
+    canisterId: principal,
+  })
+
+  try {
+    const candidSource =
+      (await actor.__get_candid_interface_tmp_hack()) as string
+
+    if (!candidSource || candidSource.trim() === "") {
+      throw new Error("Canister returned empty Candid interface")
+    }
+
+    // Parse the Candid to extract methods
+    const methods = extractMethods(candidSource)
+
+    return {
+      candidSource,
+      methods,
+      canisterId,
+      network,
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+
+    // Check for common errors
+    if (message.includes("Replica Error")) {
+      throw new Error(
+        `Canister ${canisterId} does not expose a Candid interface. ` +
+          `The canister may not support the __get_candid_interface_tmp_hack method.`
+      )
+    }
+
+    if (message.includes("not found") || message.includes("404")) {
+      throw new Error(`Canister ${canisterId} not found on ${network} network.`)
+    }
+
+    throw new Error(`Failed to fetch Candid from canister: ${message}`)
+  }
+}
+
+/**
+ * Validate a canister ID string
+ */
+export function isValidCanisterId(canisterId: string): boolean {
+  try {
+    Principal.fromText(canisterId)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get a shortened display version of a canister ID
+ */
+export function shortenCanisterId(canisterId: string): string {
+  if (canisterId.length <= 15) return canisterId
+  return `${canisterId.slice(0, 5)}...${canisterId.slice(-5)}`
+}