kash-shell 0.3.9__tar.gz → 0.3.10__tar.gz

{kash_shell-0.3.9 → kash_shell-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kash-shell
-Version: 0.3.9
+Version: 0.3.10
 Summary: The knowledge agent shell (core)
 Project-URL: Repository, https://github.com/jlevy/kash-shell
 Author-email: Joshua Levy <joshua@cal.berkeley.edu>
@@ -19,13 +19,14 @@ Requires-Python: <4.0,>=3.11
 Requires-Dist: anyio>=4.8.0
 Requires-Dist: audioop-lts>=0.2.1; python_version >= '3.13'
 Requires-Dist: cachetools>=5.5.2
-Requires-Dist: chopdiff>=0.1.3
+Requires-Dist: chopdiff>=0.2.1
+Requires-Dist: clideps>=0.1.1
 Requires-Dist: colour>=0.1.5
 Requires-Dist: cssselect>=1.2.0
 Requires-Dist: deepgram-sdk>=3.10.1
 Requires-Dist: dunamai>=1.23.0
 Requires-Dist: fastapi>=0.115.11
-Requires-Dist: flowmark>=0.3.1
+Requires-Dist: flowmark>=0.4.1
 Requires-Dist: frontmatter-format>=0.2.1
 Requires-Dist: funlog>=0.2.0
 Requires-Dist: humanfriendly>=10.0
@@ -58,7 +59,7 @@ Requires-Dist: rich>=14.0.0
 Requires-Dist: ripgrepy>=2.1.0
 Requires-Dist: send2trash>=1.8.3
 Requires-Dist: setproctitle>=1.3.5
-Requires-Dist: strif>=2.1.0
+Requires-Dist: strif>=3.0.0-rc.1
 Requires-Dist: tenacity>=9.0.0
 Requires-Dist: thefuzz>=0.22.1
 Requires-Dist: tiktoken>=0.9.0
@@ -589,8 +590,9 @@ A few of the most important commands for managing files and work are these:
   browser to view it.
 
 - `workspace` shows or selects or creates a new workspace.
-  Initially you work in the `global` workspace but for more real work you'll want to
-  create a workspace, which is a directory to hold the files you are working with.
+  Initially you work in the default global workspace (typically at `~/Kash/workspace`)
+  but for more real work you'll want to create a workspace, which is a directory to hold
+  the files you are working with.
 
 - `select` shows or sets selections, which are the set of files the next command will
   run on, within the current workspace.

{kash_shell-0.3.9 → kash_shell-0.3.10}/README.md

@@ -519,8 +519,9 @@ A few of the most important commands for managing files and work are these:
   browser to view it.
 
 - `workspace` shows or selects or creates a new workspace.
-  Initially you work in the `global` workspace but for more real work you'll want to
-  create a workspace, which is a directory to hold the files you are working with.
+  Initially you work in the default global workspace (typically at `~/Kash/workspace`)
+  but for more real work you'll want to create a workspace, which is a directory to hold
+  the files you are working with.
 
 - `select` shows or sets selections, which are the set of files the next command will
   run on, within the current workspace.

{kash_shell-0.3.9 → kash_shell-0.3.10}/pyproject.toml

@@ -42,12 +42,13 @@ dependencies = [
     "pydantic>=2.10.6",
     "typing-extensions>=4.12.2",
     # My tools:
-    "strif>=2.1.0",
+    "strif>=3.0.0-rc.1",
     "funlog>=0.2.0",
     "prettyfmt>=0.3.0",
-    "flowmark>=0.3.1",
+    "flowmark>=0.4.1",
     "frontmatter-format>=0.2.1",
-    "chopdiff>=0.1.3",
+    "chopdiff>=0.2.1",
+    "clideps>=0.1.1",
     # Shell and file essentials:
     # python-magic is most current and works with libmagic on macOS and Linux.
     # on Windows, python-magic-bin seems like the best option.
@@ -115,6 +116,9 @@ dev = [
 kash = "kash.shell.shell_main:main"
 kash-mcp = "kash.mcp.mcp_cli:main"
 
+[tool.uv.sources]
+# For local development:
+# clideps = { path = "../clideps", editable = true }
 
 # ---- Build system ----
 

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/actions/__init__.py

@@ -1,16 +1,16 @@
 from dataclasses import dataclass
 from pathlib import Path
 
+from strif import AtomicVar
+
 from kash.config.logger import get_logger
 from kash.config.settings import APP_NAME
-from kash.exec import import_action_subdirs
-from kash.utils.common.atomic_var import AtomicVar
+from kash.exec import import_and_register
 from kash.utils.common.import_utils import import_namespace_modules
 
 log = get_logger(__name__)
 
-# This hook can be used for auto-registering actions from any module.
-import_action_subdirs(["core", "meta"], __package__, Path(__file__).parent)
+import_and_register(__package__, Path(__file__).parent, ["core", "meta"])
 
 
 @dataclass(frozen=True)

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/actions/core/markdownify.py

@@ -2,6 +2,7 @@ from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, is_url_item
 from kash.model import Format, Item, ItemType
+from kash.model.params_model import common_params
 from kash.web_content.file_cache_utils import get_url_html
 from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
 
@@ -10,16 +11,18 @@ log = get_logger(__name__)
 
 @kash_action(
     precondition=is_url_item | has_html_body,
+    params=common_params("refetch"),
     mcp_tool=True,
 )
-def markdownify(item: Item) -> Item:
+def markdownify(item: Item, refetch: bool = False) -> Item:
     """
     Converts a URL or raw HTML item to Markdown, fetching with the content
     cache if needed. Also uses readability to clean up the HTML.
     """
     from markdownify import markdownify as markdownify_convert
 
-    url, html_content = get_url_html(item)
+    expiration_sec = 0 if refetch else None
+    url, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(url, html_content)
     markdown_content = markdownify_convert(page_data.clean_html)
 

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/actions/core/readability.py

@@ -2,6 +2,7 @@ from kash.config.logger import get_logger
 from kash.exec import kash_action
 from kash.exec.preconditions import has_html_body, is_url_item
 from kash.model import Format, Item, ItemType
+from kash.model.params_model import common_params
 from kash.web_content.file_cache_utils import get_url_html
 from kash.web_content.web_extract_readabilipy import extract_text_readabilipy
 
@@ -10,14 +11,16 @@ log = get_logger(__name__)
 
 @kash_action(
     precondition=is_url_item | has_html_body,
+    params=common_params("refetch"),
     mcp_tool=True,
 )
-def readability(item: Item) -> Item:
+def readability(item: Item, refetch: bool = False) -> Item:
     """
     Extracts clean HTML from a raw HTML item.
     See `markdownify` to also convert to Markdown.
     """
-    url, html_content = get_url_html(item)
+    expiration_sec = 0 if refetch else None
+    url, html_content = get_url_html(item, expiration_sec=expiration_sec)
     page_data = extract_text_readabilipy(url, html_content)
 
     output_item = item.derived_copy(

kash_shell-0.3.10/src/kash/actions/core/render_as_html.py

@@ -0,0 +1,18 @@
+from kash.actions.core.webpage_config import webpage_config
+from kash.actions.core.webpage_generate import webpage_generate
+from kash.exec import kash_action
+from kash.exec.preconditions import has_text_body, is_html
+from kash.model import ActionInput, ActionResult
+
+
+@kash_action(
+    precondition=is_html | has_text_body,
+)
+def render_as_html(input: ActionInput) -> ActionResult:
+    """
+    Convert text, Markdown, or HTML to pretty, formatted HTML using the kash default
+    page template.
+    """
+    config_result = webpage_config(input)
+    result = webpage_generate(ActionInput(items=config_result.items))
+    return result

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/actions/core/webpage_config.py

@@ -1,14 +1,22 @@
 from kash.config.logger import get_logger
 from kash.exec import kash_action
-from kash.model import ActionInput, ActionResult
+from kash.model import ActionInput, ActionResult, Param
 from kash.utils.errors import InvalidInput
 from kash.web_gen import tabbed_webpage
 
 log = get_logger(__name__)
 
 
-@kash_action()
-def webpage_config(input: ActionInput) -> ActionResult:
+@kash_action(
+    params=(
+        Param(
+            name="clean_headings",
+            type=bool,
+            description="Use an LLM to clean up headings.",
+        ),
+    )
+)
+def webpage_config(input: ActionInput, clean_headings: bool = False) -> ActionResult:
     """
     Set up a web page config with optional tabs for each page of content. Uses first item as the page title.
     """
@@ -16,6 +24,6 @@ def webpage_config(input: ActionInput) -> ActionResult:
         if not item.body:
             raise InvalidInput(f"Item must have a body: {item}")
 
-    config_item = tabbed_webpage.webpage_config(input.items)
+    config_item = tabbed_webpage.webpage_config(input.items, clean_headings)
 
     return ActionResult([config_item])

kash_shell-0.3.10/src/kash/commands/__init__.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+from kash.exec.importing import import_and_register
+
+import_and_register(
+    __package__,
+    Path(__file__).parent,
+    ["base", "extras", "help", "workspace"],
+)

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/commands/base/basic_file_commands.py

@@ -7,6 +7,7 @@ from strif import copyfile_atomic
 from kash.config.logger import get_logger
 from kash.config.text_styles import STYLE_EMPH
 from kash.exec import assemble_path_args, kash_command, resolve_path_arg
+from kash.model.paths_model import StorePath
 from kash.shell.output.shell_output import (
     PadStyle,
     PrintHooks,
@@ -21,6 +22,7 @@ from kash.utils.common.format_utils import fmt_loc
 from kash.utils.errors import InvalidInput
 from kash.utils.file_utils.file_formats_model import detect_file_format
 from kash.workspaces.workspace_output import print_file_info
+from kash.workspaces.workspaces import current_ws
 
 log = get_logger(__name__)
 
@@ -149,7 +151,20 @@ def trash(*paths: str) -> None:
     """
 
     resolved_paths = assemble_path_args(*paths)
+
+    ws = current_ws()
+    affected_store_paths = [
+        p for p in resolved_paths if isinstance(p, StorePath) and (ws.base_dir / p).exists()
+    ]
+
     native_trash(*resolved_paths)
+
+    if affected_store_paths:
+        log.info(
+            "Refreshing current selection due to deleted store paths: %s", affected_store_paths
+        )
+        ws.selections.refresh_current(ws.base_dir)
+
     print_status(f"Deleted (check trash or recycling bin to recover):\n{fmt_lines(resolved_paths)}")
 
 

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/commands/base/debug_commands.py

@@ -213,3 +213,16 @@ def reload_commands_and_actions() -> None:
 
     reload_shell_commands_and_actions()
     log_command_action_info()
+
+
+@kash_command
+def debug_exception() -> None:
+    """
+    Useful to debug exception handling/printing in xonsh.
+    """
+
+    def raise_exception():
+        cprint("Raising an unexpected exception to test the exception handler.")
+        raise Exception("This is a test exception.")
+
+    raise_exception()

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/commands/base/general_commands.py

@@ -1,9 +1,15 @@
+from clideps.env_vars.dotenv_setup import interactive_dotenv_setup
+from clideps.env_vars.dotenv_utils import load_dotenv_paths
+from clideps.env_vars.env_check import format_dotenv_check, format_env_var_check, print_env_check
+from clideps.env_vars.env_names import get_all_common_env_names
+from clideps.pkgs.pkg_check import pkg_check
+from clideps.terminal.terminal_features import terminal_check
 from flowmark import Wrap
+from rich.text import Text
 
 from kash.commands.base.model_commands import list_apis, list_models
-from kash.commands.workspace.workspace_commands import list_params
 from kash.config.logger import get_logger
-from kash.config.settings import RECOMMENDED_API_KEYS, get_system_config_dir
+from kash.config.settings import RECOMMENDED_API_KEYS, global_settings
 from kash.docs.all_docs import all_docs
 from kash.exec import kash_command
 from kash.help.tldr_help import tldr_refresh_cache
@@ -14,14 +20,6 @@ from kash.model.params_model import (
     DEFAULT_STANDARD_LLM,
     DEFAULT_STRUCTURED_LLM,
 )
-from kash.shell.clideps.api_keys import (
-    ApiEnvKey,
-    load_dotenv_paths,
-    print_api_key_setup,
-)
-from kash.shell.clideps.dotenv_setup import interactive_dotenv_setup
-from kash.shell.clideps.pkg_deps import pkg_check
-from kash.shell.clideps.terminal_features import terminal_check
 from kash.shell.input.input_prompts import input_choice
 from kash.shell.output.shell_formatting import format_name_and_value
 from kash.shell.output.shell_output import (
@@ -50,8 +48,13 @@ def self_check(brief: bool = False) -> None:
     Self-check kash setup, including termal settings, tools, and API keys.
     """
     if brief:
-        terminal_check().print_term_info()
-        print_api_key_setup(recommended_keys=RECOMMENDED_API_KEYS, once=False)
+        cprint(terminal_check().formatted())
+        cprint(Text.assemble("Dotenv files: ", format_dotenv_check()))
+        cprint(
+            Text.assemble(
+                "Env vars: ", format_env_var_check(env_vars=RECOMMENDED_API_KEYS, one_line=True)
+            )
+        )
         check_system_tools(brief=brief)
         tldr_refresh_cache()
         try:
@@ -63,7 +66,7 @@ def self_check(brief: bool = False) -> None:
     else:
         version()
         cprint()
-        terminal_check().print_term_info()
+        cprint(terminal_check().formatted())
         cprint()
         list_apis()
         cprint()
@@ -88,9 +91,10 @@ def self_configure(all: bool = False, update: bool = False) -> None:
     """
     Interactively configure API keys and preferred models.
     """
+    from kash.commands.workspace.workspace_commands import params as list_params
 
     if all:
-        api_keys = [key.value for key in ApiEnvKey]
+        api_keys = list(set(get_all_common_env_names() + RECOMMENDED_API_KEYS))
     else:
         api_keys = RECOMMENDED_API_KEYS
     # Show APIs before starting.
@@ -177,10 +181,11 @@ def reload_env() -> None:
     Reload the environment variables from the .env file.
     """
 
-    env_paths = load_dotenv_paths(True, True, get_system_config_dir())
+    env_paths = load_dotenv_paths(True, True, global_settings().system_config_dir)
     if env_paths:
         cprint("Reloaded environment variables")
-        print_api_key_setup(RECOMMENDED_API_KEYS)
+
+        print_env_check(RECOMMENDED_API_KEYS)
     else:
         raise InvalidState("No .env file found")
 

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/commands/base/logs_commands.py

@@ -7,7 +7,7 @@ from kash.config.logger import get_log_settings, get_logger, reload_rich_logging
 from kash.config.settings import (
     LogLevel,
     atomic_global_settings,
-    local_server_log_path,
+    global_settings,
 )
 from kash.exec import kash_command
 from kash.shell.output.shell_formatting import format_name_and_value
@@ -85,4 +85,6 @@ def log_settings() -> None:
     cprint(format_name_and_value("log_objects_dir", str(settings.log_objects_dir)))
     cprint(format_name_and_value("log_file_level", settings.log_file_level.name))
     cprint(format_name_and_value("log_console_level", settings.log_console_level.name))
-    cprint(format_name_and_value("server_log_file_path", str(local_server_log_path())))
+    cprint(
+        format_name_and_value("server_log_file_path", str(global_settings().local_server_log_path))
+    )

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/commands/base/model_commands.py

@@ -1,10 +1,10 @@
+from clideps.env_vars.dotenv_utils import env_var_is_set
 from flowmark import Wrap
 from rich.text import Text
 
+from kash.config.settings import get_all_common_api_env_vars
 from kash.exec.command_registry import kash_command
 from kash.llm_utils import LLM, api_for_model
-from kash.shell.clideps.api_keys import ApiEnvKey
-from kash.shell.clideps.dotenv_utils import env_var_is_set
 from kash.shell.output.shell_formatting import (
     format_failure,
     format_name_and_value,
@@ -48,11 +48,11 @@ def list_apis() -> None:
     List and check configuration for all APIs.
     """
     print_h2("API keys")
-    for api in ApiEnvKey:
-        emoji = format_success_emoji(env_var_is_set(api.value))
+    for env_var in get_all_common_api_env_vars():
+        emoji = format_success_emoji(env_var_is_set(env_var))
         message = (
-            f"API key {api.value} found"
-            if env_var_is_set(api.value)
-            else f"API key {api.value} not found"
+            f"API key {env_var} found"
+            if env_var_is_set(env_var)
+            else f"API key {env_var} not found"
         )
-        cprint(Text.assemble(emoji, format_name_and_value(api.name, message)))
+        cprint(Text.assemble(emoji, format_name_and_value(env_var, message)))

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/commands/base/search_command.py

@@ -1,9 +1,10 @@
 from pathlib import Path
 
+from clideps.pkgs.pkg_check import pkg_check
+
 from kash.config.logger import get_logger
 from kash.exec import assemble_path_args, kash_command
 from kash.exec_model.shell_model import ShellResult
-from kash.shell.clideps.pkg_deps import Pkg, pkg_check
 from kash.shell.output.shell_output import cprint
 from kash.utils.common.parse_shell_args import shell_quote
 from kash.utils.errors import InvalidState
@@ -33,7 +34,7 @@ def search(
     :param ignore_case: Ignore case when searching.
     :param verbose: Also print the ripgrep command line.
     """
-    pkg_check().require(Pkg.ripgrep)
+    pkg_check().require("ripgrep")
     from ripgrepy import RipGrepNotFound, Ripgrepy
 
     resolved_paths = assemble_path_args(*paths)

{kash_shell-0.3.9 → kash_shell-0.3.10}/src/kash/commands/base/show_command.py

@@ -18,6 +18,7 @@ def show(
     native: bool = False,
     thumbnail: bool = False,
     browser: bool = False,
+    plain: bool = False,
 ) -> None:
     """
     Show the contents of a file if one is given, or the first file if multiple files
@@ -31,10 +32,11 @@ def show(
     :param native: Force display with a native app (depending on your system configuration).
     :param thumbnail: If there is a thumbnail image, show it too.
     :param browser: Force display with your default web browser.
+    :param plain: Use plain view in the console (this is `bat`'s `plain` style).
     """
     view_mode = (
         ViewMode.console
-        if console
+        if console or plain
         else ViewMode.browser
         if browser
         else ViewMode.native
@@ -58,9 +60,9 @@ def show(
                         log.info("Had trouble showing thumbnail image (will skip): %s", e)
                         cprint(f"[Image: {item.thumbnail_url}]", style=STYLE_HINT)
 
-            view_file_native(ws.base_dir / input_path, view_mode=view_mode)
+            view_file_native(ws.base_dir / input_path, view_mode=view_mode, plain=plain)
         else:
-            view_file_native(input_path, view_mode=view_mode)
+            view_file_native(input_path, view_mode=view_mode, plain=plain)
     except (InvalidInput, InvalidState):
         if path:
             # If path is absolute or we couldbn't get a selection, just show the file.

kash_shell-0.3.10/src/kash/commands/extras/parse_uv_lock.py

@@ -0,0 +1,186 @@
+import subprocess
+import tomllib
+from pathlib import Path
+
+import pandas as pd
+from packaging.tags import Tag, sys_tags
+from packaging.utils import parse_wheel_filename
+from prettyfmt import fmt_size_dual
+from strif import atomic_output_file
+
+from kash.config.logger import get_logger
+from kash.config.text_styles import COLOR_STATUS
+from kash.exec import kash_command
+from kash.shell.output.shell_output import cprint
+
+log = get_logger(__name__)
+
+
+def choose_wheel(wheels: list[dict], allowed: list[Tag]) -> dict | None:
+    """
+    Pick the first wheel whose tag set intersects `allowed`
+    (highest priority wins).
+    """
+    priority = {tag: idx for idx, tag in enumerate(allowed)}
+    best: dict | None = None
+    best_rank = float("inf")
+
+    for meta in wheels:
+        url = meta.get("url", "")
+        filename = Path(url).name if url else ""
+        if not filename:
+            raise ValueError(f"No filename found for {url}")
+        tags = parse_wheel_filename(filename)[-1]
+
+        for tag in tags:
+            rank = priority.get(tag)
+            if rank is not None and rank < best_rank:
+                best = meta
+                best_rank = rank
+                break
+
+    return best
+
+
+def get_platform() -> str:
+    """
+    Get the most-specific platform tag your interpreter supports.
+    """
+    return next(sys_tags()).platform
+
+
+def parse_uv_lock(lock_path: Path) -> pd.DataFrame:
+    """
+    Return one row per package from a uv.lock file, selecting the best
+    matching wheel for the current interpreter or falling back to the sdist.
+
+    Columns: name, version, registry, file_type, url, hash, size, filename.
+    """
+    with open(lock_path, "rb") as f:
+        data = tomllib.load(f)
+
+    rows: list[dict] = []
+    for pkg in data.get("package", []):
+        name = pkg.get("name")
+        version = pkg.get("version")
+        registry = pkg.get("source", {}).get("registry")
+
+        wheels = pkg.get("wheels", [])
+        selected = choose_wheel(wheels, list(sys_tags()))
+        if selected:
+            meta = selected
+            file_type = "wheel"
+        else:
+            meta = pkg.get("sdist", {})
+            file_type = "sdist"
+
+        url = meta.get("url")
+        rows.append(
+            {
+                "name": name,
+                "version": version,
+                "registry": registry,
+                "file_type": file_type,
+                "url": url,
+                "hash": meta.get("hash"),
+                "size": meta.get("size"),
+                "filename": Path(url).name if url else None,
+            }
+        )
+
+    return pd.DataFrame(rows)
+
+
+def uv_runtime_packages(
+    project_dir: str | Path = ".", no_dev: bool = False, uv_executable: str = "uv"
+) -> list[str]:
+    """
+    Return the *runtime* (non-dev) package names that would be installed for the
+    given project, as resolved by uv.
+    """
+    cmd = [
+        uv_executable,
+        "export",
+        "--format",
+        "requirements-txt",
+        "--no-header",
+        "--no-annotate",
+        "--no-hashes",
+    ]
+    if no_dev:
+        cmd.append("--no-dev")
+
+    result = subprocess.run(
+        cmd,
+        cwd=Path(project_dir),
+        check=True,
+        text=True,
+        capture_output=True,
+    )
+
+    packages: list[str] = []
+    for line in result.stdout.splitlines():
+        line = line.strip()
+        if "==" not in line:  # skip “-e .” and blank lines
+            continue
+        pkg_name, _ = line.split("==", maxsplit=1)
+        packages.append(pkg_name.strip())
+
+    return packages
+
+
+@kash_command
+def uv_dep_info(
+    uv_lock: str = "uv.lock",
+    pyproject: str = "pyproject.toml",
+    save: str | None = None,
+    sort_by: str = "size",
+) -> None:
+    """
+    Parse a uv.lock file and print information about the packages.
+    By default, filters to show only 'main' dependencies from pyproject.toml.
+    Helpful for looking at sizes of dependencies.
+    """
+    uv_lock_path = Path(uv_lock)
+    pyproject_path = Path(pyproject)
+
+    main_deps: list[str] | None = None
+    all_deps: list[str] = []
+    if pyproject_path.exists():
+        cprint("Reading main dependencies from with uv", style=COLOR_STATUS)
+        main_deps = uv_runtime_packages(no_dev=True)
+        all_deps = uv_runtime_packages(no_dev=False)
+    else:
+        log.warning("pyproject.toml not found: %s", pyproject_path)
+
+    cprint(f"Parsing lock file: {uv_lock_path}", style=COLOR_STATUS)
+
+    df = parse_uv_lock(uv_lock_path)
+    df = df.sort_values(by=sort_by)
+
+    if main_deps:
+        cprint(
+            f"Filtering lock file entries to include only {len(main_deps)} of {len(all_deps)} dependencies.",
+            style=COLOR_STATUS,
+        )
+        df = df[df["name"].isin(main_deps)]
+    else:
+        cprint("Showing all packages from lock file.", style=COLOR_STATUS)
+    cprint()
+
+    # Show only selected columns and full output
+    cols = ["name", "version", "file_type", "size", "filename"]
+    print(df.loc[:, cols].to_string(max_rows=None))
+    cprint()  # Add a newline for separation
+
+    # Calculate and print summary stats
+    num_deps = len(df)
+    total_size = pd.Series(pd.to_numeric(df["size"], errors="coerce")).fillna(0).sum()
+
+    cprint(f"Packages listed: {num_deps}", style=COLOR_STATUS)
+    cprint(f"Total size: {fmt_size_dual(int(total_size))}", style=COLOR_STATUS)
+
+    if save:
+        with atomic_output_file(save) as temp_name:
+            df.to_csv(temp_name, index=False)  # Added index=False for cleaner CSV
+        cprint(f"Saved to {save}", style=COLOR_STATUS)