Programmatic API

(require '[shadow.cljs.devtools.api :as shadow])

(shadow/compile build-id)
;; Compiles a build once and returns compilation result
;; Args: build-id (keyword) - Build identifier from shadow-cljs.edn
;; Returns: map with compilation status and metadata

(shadow/compile build-id options)
;; Compiles with additional options
;; Args: build-id (keyword), options (map)
;; Options: {:debug boolean, :pseudo-names boolean, :source-maps boolean}
;; Returns: compilation result map

(shadow/watch build-id)
;; Starts watching a build for changes
;; Args: build-id (keyword)
;; Returns: watch instance map

(shadow/watch build-id options)
;; Starts watching with options
;; Args: build-id (keyword), options (map)
;; Options: {:verbose boolean, :sync boolean}
;; Returns: watch instance map

(shadow/release build-id)
;; Compiles with optimizations for production
;; Args: build-id (keyword)
;; Returns: compilation result map

(shadow/release build-id options)
;; Release compilation with options
;; Args: build-id (keyword), options (map)
;; Options: {:debug boolean, :source-maps boolean}
;; Returns: compilation result map

(shadow/check build-id)
;; Checks compilation without output
;; Args: build-id (keyword)
;; Returns: check result map with errors and warnings

(require '[shadow.cljs.devtools.api :as shadow])

;; Simple compilation
(shadow/compile :app)

;; Compilation with debug options
(shadow/compile :app {:debug true :source-maps true})

;; Start watching for development
(shadow/watch :app {:verbose true})

;; Production build
(shadow/release :app)

;; Check for errors without compiling
(let [result (shadow/check :app)]
  (when-not (:success result)
    (println "Compilation errors:" (:errors result))))

(shadow/repl build-id)
;; Starts a REPL connected to the specified build
;; Args: build-id (keyword)
;; Returns: REPL instance map

(shadow/node-repl)
;; Starts a Node.js REPL for server-side development
;; Args: none
;; Returns: Node REPL instance map

(shadow/node-repl options)
;; Node.js REPL with configuration options
;; Args: options (map)
;; Options: {:port number, :host string}
;; Returns: Node REPL instance map

(shadow/browser-repl)
;; Starts a browser REPL for general ClojureScript development
;; Args: none
;; Returns: browser REPL instance map

(shadow/browser-repl options)
;; Browser REPL with options
;; Args: options (map)
;; Options: {:port number, :host string, :ssl boolean}
;; Returns: browser REPL instance map

;; Start build-specific REPL
(shadow/repl :app)

;; Start Node.js REPL on custom port
(shadow/node-repl {:port 8081})

;; Start browser REPL with SSL
(shadow/browser-repl {:ssl true :port 9000})

(shadow/get-runtime!)
;; Gets the current runtime instance
;; Args: none
;; Returns: runtime map

(shadow/get-runtime! build-id)
;; Gets the runtime instance for a build
;; Args: build-id (keyword)
;; Returns: runtime map or nil if not found

(shadow/with-runtime build-id body)
;; Executes code within a runtime context
;; Args: build-id (keyword), body (any)
;; Returns: execution result

(shadow/active-builds)
;; Returns list of currently active builds
;; Args: none
;; Returns: vector of build-id keywords

(shadow/get-build-ids)
;; Returns all configured build IDs from shadow-cljs.edn
;; Args: none
;; Returns: set of build-id keywords

(shadow/worker-running? build-id)
;; Checks if a build worker is currently running
;; Args: build-id (keyword)
;; Returns: boolean

(shadow/repl-runtimes)
;; Gets all available REPL runtimes
;; Args: none
;; Returns: map of runtime-id to runtime info

;; Check active builds
(def builds (shadow/active-builds))
(println "Active builds:" builds)

;; Get runtime for specific build
(when-let [runtime (shadow/get-runtime! :app)]
  (println "Runtime info:" runtime))

;; Execute in runtime context
(shadow/with-runtime :app
  (js/console.log "Hello from runtime!"))

;; Check if worker is running
(if (shadow/worker-running? :app)
  (println "Build worker is active")
  (println "Build worker is stopped"))

(shadow/start-server!)
;; Starts the Shadow-CLJS development server
;; Args: none
;; Returns: server instance map

(shadow/start-server! config)
;; Starts server with configuration
;; Args: config (map)
;; Config: {:port number, :host string, :ssl boolean}
;; Returns: server instance map

(shadow/stop-server!)
;; Stops the development server
;; Args: none
;; Returns: stop result map

(shadow/server-running?)
;; Checks if development server is running
;; Args: none
;; Returns: boolean

(shadow/get-server-instance)
;; Gets the current server instance
;; Args: none
;; Returns: server instance map or nil

;; Start development server
(shadow/start-server!)

;; Start server on custom port
(shadow/start-server! {:port 8080 :host "0.0.0.0"})

;; Check server status
(when (shadow/server-running?)
  (println "Server is running"))

;; Stop server
(shadow/stop-server!)

(shadow/watch-compile! build-id)
;; Manually trigger recompilation for a watch build
;; Args: build-id (keyword)
;; Returns: :ok or :watch-not-running

(shadow/watch-compile-all!)
;; Trigger recompilation for all running watch builds
;; Args: none
;; Returns: :ok

(shadow/watch-set-autobuild! build-id toggle)
;; Enable or disable autobuild for a watch build
;; Args: build-id (keyword), toggle (boolean)
;; Returns: :ok or :watch-not-running

;; Manually compile a watch build
(shadow/watch-compile! :app)

;; Compile all active watch builds
(shadow/watch-compile-all!)

;; Enable autobuild for a watch
(shadow/watch-set-autobuild! :app true)

;; Disable autobuild for a watch
(shadow/watch-set-autobuild! :app false)

(shadow/reload-deps!)
;; Reload project dependencies without restarting
;; Args: none
;; Returns: ::loaded, ::no-changes, ::conflicts, or ::standalone-only

(shadow/reload-deps! opts)
;; Reload dependencies with options
;; Args: opts (map) - {:deps deps-map, :ignore-conflicts boolean}
;; Returns: reload result keyword

;; Simple dependency reload
(shadow/reload-deps!)

;; Reload with specific dependencies
(shadow/reload-deps! {:deps {'some/lib {:mvn/version "1.2.3"}}})

;; Ignore version conflicts
(shadow/reload-deps! {:ignore-conflicts true})

(require '[shadow.build.api :as build])

(build/compile-stage build-state stage options)
;; Executes a specific compilation stage
;; Args: build-state (map), stage (keyword), options (map)
;; Returns: updated build-state map

(build/configure-modules build-state modules-config)
;; Configures build modules
;; Args: build-state (map), modules-config (map)
;; Returns: updated build-state map

(build/compile-modules build-state)
;; Compiles configured modules
;; Args: build-state (map)
;; Returns: updated build-state map

(build/optimize-modules build-state optimizer-options)
;; Applies optimizations to compiled modules
;; Args: build-state (map), optimizer-options (map)
;; Returns: updated build-state map

(build/flush-modules-to-disk build-state output-dir)
;; Writes compiled modules to disk
;; Args: build-state (map), output-dir (string)
;; Returns: updated build-state map

(build/get-output build-state)
;; Gets compilation output information
;; Args: build-state (map)
;; Returns: output map with file paths and metadata

(require '[shadow.cljs.devtools.config :as config])

(config/load-cljs-edn)
;; Loads shadow-cljs.edn from current directory
;; Args: none
;; Returns: configuration map

(config/load-cljs-edn config-file)
;; Loads configuration from specific file
;; Args: config-file (string path)
;; Returns: configuration map

(config/get-config)
;; Gets current global configuration
;; Args: none
;; Returns: configuration map

(config/get-build-config build-id)
;; Gets configuration for specific build
;; Args: build-id (keyword)
;; Returns: build configuration map

(config/normalize-config config)
;; Normalizes configuration structure
;; Args: config (map)
;; Returns: normalized configuration map

(config/validate-config config)
;; Validates configuration structure and values
;; Args: config (map)
;; Returns: validation result map

(require '[shadow.cljs.devtools.config :as config])

;; Load and validate configuration
(let [config (config/load-cljs-edn)]
  (if-let [validation (config/validate-config config)]
    (println "Config valid")
    (println "Config errors:" validation)))

;; Get build-specific configuration
(def app-config (config/get-build-config :app))
(println "Output directory:" (:output-dir app-config))