pulse-framework 0.1.51__py3-none-any.whl → 0.1.53__py3-none-any.whl

pulse/cli/helpers.py

@@ -1,15 +1,19 @@
+from __future__ import annotations
+
 import importlib
 import importlib.util
 import platform
 import sys
 from pathlib import Path
-from typing import Literal, TypedDict
+from typing import TYPE_CHECKING, Literal, TypedDict
 
 import typer
-from rich.console import Console
 
 from pulse.cli.models import AppLoadResult
 
+if TYPE_CHECKING:
+	from pulse.cli.logging import CLILogger
+
 
 def os_family() -> Literal["windows", "mac", "linux"]:
 	s = platform.system().lower()
@@ -110,66 +114,35 @@ def parse_app_target(target: str) -> ParsedAppTarget:
 	}
 
 
-def load_app_from_file(file_path: str | Path) -> AppLoadResult:
-	"""Load routes from a Python file and return app context details."""
+def load_app_from_target(target: str, logger: CLILogger | None = None) -> AppLoadResult:
+	"""Load an App instance from either a file path (with optional :var) or a module path (uvicorn style).
+
+	Args:
+		target: The app target string (file path or module path)
+		logger: Optional CLILogger for error output. If not provided, uses basic print/traceback.
+	"""
 	# Avoid circular import
 	from pulse.app import App
 
-	file_path = Path(file_path)
-
-	if not file_path.exists():
-		typer.echo(f"❌ File not found: {file_path}")
-		raise typer.Exit(1)
-
-	if not file_path.suffix == ".py":
-		typer.echo(f"❌ File must be a Python file (.py): {file_path}")
-		raise typer.Exit(1)
-
-	# clear_routes()
-	sys.path.insert(0, str(file_path.parent.absolute()))
-
-	try:
-		spec = importlib.util.spec_from_file_location("user_app", file_path)
-		if spec is None or spec.loader is None:
-			typer.echo(f"❌ Could not load module from: {file_path}")
-			raise typer.Exit(1)
-
-		module = importlib.util.module_from_spec(spec)
-		spec.loader.exec_module(module)
-
-		if hasattr(module, "app") and isinstance(module.app, App):
-			app_instance = module.app
-			if not app_instance.routes:
-				typer.echo(f"⚠️  No routes found in {file_path}")
-			return AppLoadResult(
-				target=str(file_path),
-				mode="path",
-				app=app_instance,
-				module_name="user_app",
-				app_var="app",
-				app_file=file_path.resolve(),
-				app_dir=file_path.parent.resolve(),
-				server_cwd=file_path.parent.resolve(),
-			)
-
-		typer.echo(f"⚠️  No app found in {file_path}")
-		raise typer.Exit(1)
-
-	except Exception:
-		console = Console()
-		console.log(f"❌ Error loading {file_path}")
-		console.print_exception()
-		raise typer.Exit(1) from None
-	finally:
-		if str(file_path.parent.absolute()) in sys.path:
-			sys.path.remove(str(file_path.parent.absolute()))
+	def _log_error(message: str) -> None:
+		if logger:
+			logger.error(message)
+		else:
+			print(f"Error: {message}")
 
+	def _log_warning(message: str) -> None:
+		if logger:
+			logger.warning(message)
+		else:
+			print(f"Warning: {message}")
 
-def load_app_from_target(target: str) -> AppLoadResult:
-	"""Load an App instance from either a file path (with optional :var) or a module path (uvicorn style)."""
+	def _print_exception() -> None:
+		if logger:
+			logger.print_exception()
+		else:
+			import traceback
 
-	# Avoid circulart import
-	from pulse.app import App
+			traceback.print_exc()
 
 	parsed = parse_app_target(target)
 
@@ -181,22 +154,23 @@ def load_app_from_target(target: str) -> AppLoadResult:
 	if parsed["mode"] == "path":
 		file_path = parsed["file_path"]
 		if file_path is None:
-			typer.echo(f"❌ Could not determine a Python file from: {target}")
+			_log_error(f"Could not determine a Python file from: {target}")
 			raise typer.Exit(1)
 
 		sys.path.insert(0, str(file_path.parent.absolute()))
 		try:
 			spec = importlib.util.spec_from_file_location(module_name, file_path)
 			if spec is None or spec.loader is None:
-				typer.echo(f"❌ Could not load module from: {file_path}")
+				_log_error(f"Could not load module from: {file_path}")
 				raise typer.Exit(1)
 			module = importlib.util.module_from_spec(spec)
 			sys.modules[spec.name] = module
 			spec.loader.exec_module(module)
+		except typer.Exit:
+			raise
 		except Exception:
-			console = Console()
-			console.log(f"❌ Error loading {file_path}")
-			console.print_exception()
+			_log_error(f"Error loading {file_path}")
+			_print_exception()
 			raise typer.Exit(1) from None
 		finally:
 			if str(file_path.parent.absolute()) in sys.path:
@@ -210,9 +184,8 @@ def load_app_from_target(target: str) -> AppLoadResult:
 		try:
 			module = importlib.import_module(module_name)  # type: ignore[name-defined]
 		except Exception:
-			console = Console()
-			console.log(f"❌ Error importing module: {module_name}")
-			console.print_exception()
+			_log_error(f"Error importing module: {module_name}")
+			_print_exception()
 			raise typer.Exit(1) from None
 
 		# Try to set env paths from the resolved module file
@@ -225,14 +198,14 @@ def load_app_from_target(target: str) -> AppLoadResult:
 
 	# Fetch the app attribute
 	if not hasattr(loaded_module, app_var):
-		typer.echo(f"❌ App variable '{app_var}' not found in {module_name}")
+		_log_error(f"App variable '{app_var}' not found in {module_name}")
 		raise typer.Exit(1)
 	app_candidate = getattr(loaded_module, app_var)
 	if not isinstance(app_candidate, App):
-		typer.echo(f"❌ '{app_var}' in {module_name} is not a pulse.App instance")
+		_log_error(f"'{app_var}' in {module_name} is not a pulse.App instance")
 		raise typer.Exit(1)
 	if not app_candidate.routes:
-		typer.echo("⚠️  No routes found")
+		_log_warning("No routes found")
 	return AppLoadResult(
 		target=target,
 		mode=parsed["mode"],

pulse/cli/logging.py

@@ -0,0 +1,102 @@
+"""
+Mode-aware CLI logging for Pulse.
+
+In dev mode, uses Rich Console with colors.
+In ci/prod mode or with --plain, uses plain print().
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Literal
+
+from pulse.env import PulseEnv
+
+if TYPE_CHECKING:
+	from rich.console import Console
+
+TagMode = Literal["colored", "plain"]
+
+
+class CLILogger:
+	"""Mode-aware CLI logger that adapts output based on pulse environment.
+
+	Args:
+		mode: The pulse environment mode (dev, ci, prod)
+		plain: Force plain output without colors, even in dev mode
+	"""
+
+	mode: PulseEnv
+	plain: bool
+	_console: Console | None
+
+	def __init__(self, mode: PulseEnv = "dev", *, plain: bool = False):
+		self.mode = mode
+		self.plain = plain
+		self._console = None
+		if mode == "dev" and not plain:
+			from rich.console import Console
+
+			self._console = Console()
+
+	@property
+	def is_plain(self) -> bool:
+		"""Return True if using plain output (ci/prod mode or --plain flag)."""
+		return self.mode != "dev" or self.plain
+
+	def print(self, message: str) -> None:
+		"""Print a message."""
+		if self._console:
+			self._console.print(message)
+		else:
+			print(message)
+
+	def error(self, message: str) -> None:
+		"""Print an error message."""
+		if self._console:
+			self._console.print(f"[red]Error:[/red] {message}")
+		else:
+			print(f"Error: {message}")
+
+	def success(self, message: str) -> None:
+		"""Print a success message."""
+		if self._console:
+			self._console.print(f"[green]✓[/green] {message}")
+		else:
+			print(f"Done: {message}")
+
+	def warning(self, message: str) -> None:
+		"""Print a warning message."""
+		if self._console:
+			self._console.print(f"[yellow]Warning:[/yellow] {message}")
+		else:
+			print(f"Warning: {message}")
+
+	def print_exception(self) -> None:
+		"""Print the current exception."""
+		if self._console:
+			self._console.print_exception()
+		else:
+			import traceback
+
+			traceback.print_exc()
+
+	def get_tag_mode(self) -> TagMode:
+		"""Return tag mode for process output: colored in dev, plain in ci/prod."""
+		return "plain" if self.is_plain else "colored"
+
+	def write_ready_announcement(
+		self, address: str, port: int, server_url: str
+	) -> None:
+		"""Write the 'Pulse is ready' announcement."""
+		if self._console:
+			self._console.print("")
+			self._console.print(
+				f"[bold green]Ready:[/bold green] [bold cyan][link={server_url}]{server_url}[/link][/bold cyan]"
+			)
+			self._console.print("")
+		else:
+			print("")
+			print(f"Ready: {server_url}")
+			print("")
+		sys.stdout.flush()

pulse/cli/packages.py

@@ -116,6 +116,22 @@ def pick_more_specific(a: str | None, b: str | None) -> str | None:
 		return a
 	if b_exact:
 		return b
+
+	# If both are ranges, prefer higher version if possible (heuristic)
+	if a.startswith(("^", "~")) and b.startswith(("^", "~")):
+		av = a[1:]
+		bv = b[1:]
+		# Basic version comparison for digits
+		try:
+			a_parts = [int(p) for p in av.split(".") if p.isdigit()]
+			b_parts = [int(p) for p in bv.split(".") if p.isdigit()]
+			if a_parts > b_parts:
+				return a
+			if b_parts > a_parts:
+				return b
+		except ValueError:
+			pass
+
 	# Prefer longer constraint as proxy for specificity
 	return a if len(a) >= len(b) else b
 

pulse/cli/processes.py

@@ -8,23 +8,26 @@ import select
 import signal
 import subprocess
 import sys
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from io import TextIOBase
 from typing import TypeVar, cast
 
-from rich.console import Console
-
 from pulse.cli.helpers import os_family
+from pulse.cli.logging import TagMode
 from pulse.cli.models import CommandSpec
 
 _K = TypeVar("_K", int, str)
 
+# ANSI color codes for tagged output
 ANSI_CODES = {
 	"cyan": "\033[36m",
 	"orange1": "\033[38;5;208m",
-	"default": "\033[90m",
+	"reset": "\033[0m",
 }
 
+# Tag colors mapping (used only in colored mode)
+TAG_COLORS = {"server": "cyan", "web": "orange1"}
+
 # Regex to strip ANSI escape codes
 ANSI_ESCAPE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
 
@@ -32,23 +35,27 @@ ANSI_ESCAPE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
 def execute_commands(
 	commands: Sequence[CommandSpec],
 	*,
-	console: Console,
-	tag_colors: Mapping[str, str] | None = None,
+	tag_mode: TagMode = "colored",
 ) -> int:
-	"""Run the provided commands, streaming tagged output to stdout."""
+	"""Run the provided commands, streaming tagged output to stdout.
+
+	Args:
+		commands: List of command specifications to run
+		tag_mode: How to display process tags:
+			- "colored": Show [server]/[web] with ANSI colors (dev mode)
+			- "plain": Show [server]/[web] without colors (ci/prod mode)
+	"""
 	if not commands:
 		return 0
 
-	color_lookup = dict(tag_colors or {})
-
 	# Avoid pty.fork() in multi-threaded environments (like pytest) to prevent
 	# "DeprecationWarning: This process is multi-threaded, use of forkpty() may lead to deadlocks"
 	# Also skip pty on Windows or if fork is unavailable
 	in_pytest = "pytest" in sys.modules
 	if os_family() == "windows" or not hasattr(pty, "fork") or in_pytest:
-		return _run_without_pty(commands, console=console, colors=color_lookup)
+		return _run_without_pty(commands, tag_mode=tag_mode)
 
-	return _run_with_pty(commands, console=console, colors=color_lookup)
+	return _run_with_pty(commands, tag_mode=tag_mode)
 
 
 def _call_on_spawn(spec: CommandSpec) -> None:
@@ -82,8 +89,7 @@ def _check_on_ready(
 def _run_with_pty(
 	commands: Sequence[CommandSpec],
 	*,
-	console: Console,
-	colors: Mapping[str, str],
+	tag_mode: TagMode,
 ) -> int:
 	procs: list[tuple[str, int, int]] = []
 	fd_to_spec: dict[int, CommandSpec] = {}
@@ -138,7 +144,7 @@ def _run_with_pty(
 						decoded = line.decode(errors="replace")
 						if decoded:
 							spec = fd_to_spec[fd]
-							_write_tagged_line(spec.name, decoded, colors)
+							_write_tagged_line(spec.name, decoded, tag_mode)
 							_check_on_ready(spec, decoded, ready_flags, fd)
 				except OSError:
 					continue
@@ -173,8 +179,7 @@ def _run_with_pty(
 def _run_without_pty(
 	commands: Sequence[CommandSpec],
 	*,
-	console: Console,
-	colors: Mapping[str, str],
+	tag_mode: TagMode,
 ) -> int:
 	from selectors import EVENT_READ, DefaultSelector
 
@@ -211,7 +216,7 @@ def _run_without_pty(
 				# stream is now guaranteed to be a file-like object
 				line = cast(TextIOBase, stream).readline()
 				if line:
-					_write_tagged_line(name, line.rstrip("\n"), colors)
+					_write_tagged_line(name, line.rstrip("\n"), tag_mode)
 					spec = next((s for n, _, s in procs if n == name), None)
 					if spec:
 						_check_on_ready(spec, line, ready_flags, name)
@@ -251,7 +256,16 @@ def _run_without_pty(
 	return max(exit_codes) if exit_codes else 0
 
 
-def _write_tagged_line(name: str, message: str, colors: Mapping[str, str]) -> None:
+def _write_tagged_line(name: str, message: str, tag_mode: TagMode) -> None:
+	"""Write a line of output with optional process tag.
+
+	Args:
+		name: Process name (e.g., "server", "web")
+		message: The line of output to write
+		tag_mode: How to display the tag:
+			- "colored": Show [name] with ANSI colors
+			- "plain": Show [name] without colors
+	"""
 	# Filter out unwanted web server messages
 	clean_message = ANSI_ESCAPE.sub("", message)
 	if (
@@ -261,12 +275,15 @@ def _write_tagged_line(name: str, message: str, colors: Mapping[str, str]) -> No
 	):
 		return
 
-	# Only add tags if colors dict is not empty (i.e., tagging is enabled)
-	if colors:
-		color = ANSI_CODES.get(colors.get(name, ""), ANSI_CODES["default"])
-		sys.stdout.write(f"{color}[{name}]\033[0m {message}\n")
+	if tag_mode == "colored":
+		color = ANSI_CODES.get(TAG_COLORS.get(name, ""), "")
+		if color:
+			sys.stdout.write(f"{color}[{name}]{ANSI_CODES['reset']} {message}\n")
+		else:
+			sys.stdout.write(f"[{name}] {message}\n")
 	else:
-		sys.stdout.write(f"{message}\n")
+		# Plain mode: tags without color
+		sys.stdout.write(f"[{name}] {message}\n")
 	sys.stdout.flush()
 
 

pulse/codegen/codegen.py

@@ -1,4 +1,5 @@
 import logging
+import shutil
 from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -13,7 +14,7 @@ from pulse.codegen.templates.routes_ts import (
 )
 from pulse.env import env
 from pulse.routing import Layout, Route, RouteTree
-from pulse.transpiler.imports import registered_imports
+from pulse.transpiler import get_registered_imports
 
 if TYPE_CHECKING:
 	from pulse.app import ConnectionStatusConfig
@@ -99,14 +100,16 @@ class Codegen:
 	def __init__(self, routes: RouteTree, config: CodegenConfig) -> None:
 		self.cfg = config
 		self.routes = routes
-		self._copied_css_files: set[Path] = set()
-		# Maps source path -> destination path for CSS files
-		self._css_dest_paths: dict[str, Path] = {}
+		self._copied_files: set[Path] = set()
 
 	@property
 	def output_folder(self):
 		return self.cfg.pulse_path
 
+	@property
+	def assets_folder(self):
+		return self.output_folder / "assets"
+
 	def generate_all(
 		self,
 		server_address: str,
@@ -117,11 +120,10 @@ class Codegen:
 		# Ensure generated files are gitignored
 		ensure_gitignore_has(self.cfg.web_root, f"app/{self.cfg.pulse_dir}/")
 
-		self._copied_css_files = set()
-		self._css_dest_paths = {}
+		self._copied_files = set()
 
-		# Copy all registered CSS files to the output css directory
-		self._copy_css_files()
+		# Copy all registered local files to the assets directory
+		asset_import_paths = self._copy_local_files()
 
 		# Keep track of all generated files
 		generated_files = set(
@@ -135,12 +137,16 @@ class Codegen:
 				self.generate_routes_ts(),
 				self.generate_routes_runtime_ts(),
 				*(
-					self.generate_route(route, server_address=server_address)
+					self.generate_route(
+						route,
+						server_address=server_address,
+						asset_import_paths=asset_import_paths,
+					)
 					for route in self.routes.flat_tree.values()
 				),
 			]
 		)
-		generated_files.update(self._copied_css_files)
+		generated_files.update(self._copied_files)
 
 		# Clean up any remaining files that are not part of the generated files
 		for path in self.output_folder.rglob("*"):
@@ -151,31 +157,52 @@ class Codegen:
 				except Exception as e:
 					logger.warning(f"Could not remove stale file {path}: {e}")
 
-	def _copy_css_files(self) -> None:
-		"""Copy all registered local CSS files to the output css directory."""
-		from pulse.transpiler.imports import CssImport
+	def _copy_local_files(self) -> dict[str, str]:
+		"""Copy all registered local files to the assets directory.
+
+		Collects all Import objects with is_local=True and copies their
+		source files to the assets folder, returning an import path mapping.
+		"""
+		imports = get_registered_imports()
+		local_imports = [imp for imp in imports if imp.is_local]
+
+		if not local_imports:
+			return {}
 
-		css_dir = self.output_folder / "css"
+		self.assets_folder.mkdir(parents=True, exist_ok=True)
+		asset_import_paths: dict[str, str] = {}
 
-		for imp in registered_imports():
-			if not isinstance(imp, CssImport) or not imp.is_local:
+		for imp in local_imports:
+			if imp.source_path is None:
 				continue
 
-			# Local CssImport has source_path and generated_filename set
-			source_path = imp.source_path
-			generated_filename = imp.generated_filename
-			assert source_path is not None and generated_filename is not None
+			asset_filename = imp.asset_filename()
+			dest_path = self.assets_folder / asset_filename
 
-			if not source_path.exists():
-				logger.warning(f"CSS file not found: {source_path}")
-				continue
+			# Copy file if source exists
+			if imp.source_path.exists():
+				shutil.copy2(imp.source_path, dest_path)
+				self._copied_files.add(dest_path)
+				logger.debug(f"Copied {imp.source_path} -> {dest_path}")
+
+			# Store just the asset filename - the relative path is computed per-route
+			asset_import_paths[imp.src] = asset_filename
 
-			dest_path = css_dir / generated_filename
-			dest_path.parent.mkdir(parents=True, exist_ok=True)
-			content = source_path.read_text()
-			write_file_if_changed(dest_path, content)
-			self._copied_css_files.add(dest_path)
-			self._css_dest_paths[str(source_path)] = dest_path
+		return asset_import_paths
+
+	def _compute_asset_prefix(self, route_file_path: str) -> str:
+		"""Compute the relative path prefix from a route file to the assets folder.
+
+		Args:
+			route_file_path: The route's file path (e.g., "users/_id_xxx.jsx")
+
+		Returns:
+			The relative path prefix (e.g., "../assets/" or "../../assets/")
+		"""
+		# Count directory depth: each "/" in the path adds one level
+		depth = route_file_path.count("/")
+		# Add 1 for the routes/ or layouts/ folder itself
+		return "../" * (depth + 1) + "assets/"
 
 	def generate_layout_tsx(
 		self,
@@ -250,17 +277,25 @@ class Codegen:
 					)
 		return "\n".join(lines)
 
-	def generate_route(self, route: Route | Layout, server_address: str):
+	def generate_route(
+		self,
+		route: Route | Layout,
+		server_address: str,
+		asset_import_paths: dict[str, str],
+	):
+		route_file_path = route.file_path()
 		if isinstance(route, Layout):
-			output_path = self.output_folder / "layouts" / route.file_path()
+			output_path = self.output_folder / "layouts" / route_file_path
 		else:
-			output_path = self.output_folder / "routes" / route.file_path()
+			output_path = self.output_folder / "routes" / route_file_path
+
+		# Compute asset prefix based on route depth
+		asset_prefix = self._compute_asset_prefix(route_file_path)
 
 		content = generate_route(
 			path=route.unique_path(),
-			components=list(route.components) if route.components else None,
-			route_file_path=output_path,
-			css_dir=self.output_folder / "css",
+			asset_filenames=asset_import_paths,
+			asset_prefix=asset_prefix,
 		)
 		return write_file_if_changed(output_path, content)
 

pulse/codegen/js.py

@@ -43,10 +43,8 @@ class ExternalJsFunction(Generic[*Args, R]):
 		is_default: bool,
 		hint: Callable[[*Args], R],
 	) -> None:
-		if is_default:
-			self.import_ = Import.default(name, src)
-		else:
-			self.import_ = Import.named(name, src)
+		kind = "default" if is_default else "named"
+		self.import_ = Import(name, src, kind=kind)
 		self._prop = prop
 		self.hint = hint