cli-mem 0.2.0__tar.gz → 0.2.1__tar.gz

{cli_mem-0.2.0 → cli_mem-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-mem
-Version: 0.2.0
+Version: 0.2.1
 Summary: Privacy-first CLI that turns shell history into searchable memory
 Project-URL: GitHub, https://github.com/matinsaurralde/mem
 Author: Matias Insaurralde

{cli_mem-0.2.0 → cli_mem-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cli-mem"
-version = "0.2.0"
+version = "0.2.1"
 description = "Privacy-first CLI that turns shell history into searchable memory"
 license = "MIT"
 readme = "README.md"

{cli_mem-0.2.0 → cli_mem-0.2.1}/src/mem/__init__.py

@@ -1,3 +1,3 @@
 """mem — your shell history, understood."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{cli_mem-0.2.0 → cli_mem-0.2.1}/src/mem/cli.py

@@ -400,10 +400,11 @@ def save(command: str, group_name: str | None, global_flag: bool, comment: str |
 
 
 @cli.command(name="list")
+@click.argument("group_name", required=False, default=None)
 @click.option("--global", "global_flag", is_flag=True, help="Show only global scope")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
-def list_cmd(global_flag: bool, as_json: bool) -> None:
-    """List saved commands and groups."""
+def list_cmd(group_name: str | None, global_flag: bool, as_json: bool) -> None:
+    """List saved commands and groups, or show a group's commands."""
     from mem import groups, storage
 
     global_path = storage.GROUPS_GLOBAL_FILE
@@ -415,6 +416,28 @@ def list_cmd(global_flag: bool, as_json: bool) -> None:
             sanitized = storage.sanitize_repo_name(repo)
             repo_path = storage.group_file_path(sanitized)
 
+    # Show a specific group's commands
+    if group_name is not None:
+        grp, scope_label, _file_path, shadows = groups.resolve_group(
+            group_name, repo_path, global_path, force_global=global_flag,
+        )
+
+        if as_json:
+            click.echo(groups.export_json(group_name, grp))
+            return
+
+        console.print(f"\n● {scope_label} / {group_name}")
+        if grp.description:
+            console.print(f'  "{grp.description}"')
+        if group_name in shadows and scope_label != "global":
+            console.print("  [dim](global group with same name exists — use --global to see it)[/]")
+        console.print("  " + "─" * 50)
+        for i, cmd in enumerate(grp.commands, 1):
+            comment_str = f"   # {cmd.comment}" if cmd.comment else ""
+            console.print(f"  {i}. {cmd.cmd}{comment_str}")
+        console.print()
+        return
+
     result = groups.list_all(repo_path, global_path)
 
     if as_json:
@@ -528,6 +551,7 @@ def run(group_name: str, global_flag: bool, yes: bool) -> None:
         return
 
     # Determine which commands to run
+    run_all = yes
     if not yes:
         choice = click.prompt(
             f"  Run all? [y/N] or pick [1-{len(grp.commands)}]",
@@ -539,6 +563,7 @@ def run(group_name: str, global_flag: bool, yes: bool) -> None:
             return
 
         if choice.lower() == "y":
+            run_all = True
             commands_to_run = list(enumerate(grp.commands, 1))
         else:
             try:
@@ -557,7 +582,7 @@ def run(group_name: str, global_flag: bool, yes: bool) -> None:
     # Execute
     console.print()
     for i, cmd in commands_to_run:
-        if not yes and len(commands_to_run) > 1:
+        if not run_all and len(commands_to_run) > 1:
             if not click.confirm(f"  Run [{i}] {cmd.cmd}?", default=True, err=True):
                 continue
 

{cli_mem-0.2.0 → cli_mem-0.2.1}/src/mem/groups.py

@@ -32,16 +32,14 @@ def resolve_scope(global_flag: bool) -> Path:
     """Return the path to the data file for the target scope.
 
     Uses the current git repo for scoping unless --global is set.
-    Raises ClickException if outside a git repo without --global.
+    Falls back to global scope when outside a git repo.
     """
     if global_flag:
         return storage.GROUPS_GLOBAL_FILE
 
     repo = get_git_repo(os.getcwd())
     if repo is None:
-        raise click.ClickException(
-            "Not in a git repository. Use --global to save globally."
-        )
+        return storage.GROUPS_GLOBAL_FILE
     sanitized = storage.sanitize_repo_name(repo)
     return storage.group_file_path(sanitized)
 

{cli_mem-0.2.0 → cli_mem-0.2.1}/tests/test_groups.py

@@ -603,13 +603,14 @@ class TestSaveCLI:
         assert result.exit_code == 0
         assert "Already saved" in result.output
 
-    def test_save_outside_repo_without_global_errors(self, tmp_mem_dir: Path):
+    def test_save_outside_repo_falls_back_to_global(self, tmp_mem_dir: Path):
         runner = CliRunner()
         with patch("mem.cli._current_repo", return_value=None), \
              patch("mem.groups.get_git_repo", return_value=None):
             result = runner.invoke(cli, ["save", "echo hello"])
-        assert result.exit_code != 0
-        assert "git repository" in result.output.lower() or "git repository" in str(result.exception).lower()
+        assert result.exit_code == 0
+        data = storage.read_group_file(storage.GROUPS_GLOBAL_FILE)
+        assert any(s.cmd == "echo hello" for s in data.saved)
 
     def test_save_in_repo(self, tmp_mem_dir: Path):
         runner = CliRunner()
@@ -675,6 +676,44 @@ class TestListCLI:
         assert result.exit_code == 0
         assert "shadowed" in result.output
 
+    def test_list_specific_group(self, tmp_mem_dir: Path):
+        storage.write_group_file(
+            storage.GROUPS_GLOBAL_FILE,
+            GroupFile(groups={"deploy": Group(
+                description="deploy steps",
+                commands=[
+                    GroupCommand(cmd="make build", comment="compile"),
+                    GroupCommand(cmd="make push"),
+                ],
+            )}),
+        )
+        runner = CliRunner()
+        result = runner.invoke(cli, ["list", "deploy", "--global"])
+        assert result.exit_code == 0
+        assert "deploy" in result.output
+        assert "make build" in result.output
+        assert "compile" in result.output
+        assert "make push" in result.output
+
+    def test_list_specific_group_not_found(self, tmp_mem_dir: Path):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["list", "nope", "--global"])
+        assert result.exit_code != 0
+        assert "not found" in result.output.lower()
+
+    def test_list_specific_group_json(self, tmp_mem_dir: Path):
+        storage.write_group_file(
+            storage.GROUPS_GLOBAL_FILE,
+            GroupFile(groups={"g": Group(
+                commands=[GroupCommand(cmd="echo hi")],
+            )}),
+        )
+        runner = CliRunner()
+        result = runner.invoke(cli, ["list", "g", "--global", "--json"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "g" in data
+
 
 class TestRunCLI:
     def _setup_group(self, tmp_mem_dir: Path):
@@ -723,6 +762,20 @@ class TestRunCLI:
             result = runner.invoke(cli, ["run", "test", "--global"], input="n\n")
         assert result.exit_code == 0
 
+    def test_run_all_skips_per_command_confirm(self, tmp_mem_dir: Path):
+        self._setup_group(tmp_mem_dir)
+        runner = CliRunner()
+        with patch("mem.cli._is_interactive", return_value=True):
+            # "y\n" = run all — should NOT prompt for each command
+            result = runner.invoke(cli, ["run", "test", "--global"], input="y\n")
+        assert result.exit_code == 0
+        # All 3 commands should appear as executed ($ echo N)
+        assert "$ echo 1" in result.output
+        assert "$ echo 2" in result.output
+        assert "$ echo 3" in result.output
+        # Should NOT contain per-command confirmation prompts
+        assert "Run [1]" not in result.output
+
     def test_run_non_tty_without_yes_errors(self, tmp_mem_dir: Path):
         self._setup_group(tmp_mem_dir)
         runner = CliRunner()
@@ -1159,10 +1212,10 @@ class TestResolveScope:
         expected_name = storage.sanitize_repo_name(FAKE_REPO)
         assert path == storage.group_file_path(expected_name)
 
-    def test_outside_repo_raises(self, tmp_mem_dir: Path):
+    def test_outside_repo_falls_back_to_global(self, tmp_mem_dir: Path):
         with patch("mem.groups.get_git_repo", return_value=None):
-            with pytest.raises(click.ClickException, match="git repository"):
-                groups.resolve_scope(global_flag=False)
+            path = groups.resolve_scope(global_flag=False)
+        assert path == storage.GROUPS_GLOBAL_FILE
 
 
 class TestSaveNonInteractive: