insightfactory-cli 1.0.0.dev1__tar.gz → 1.0.0.dev4__tar.gz

{insightfactory_cli-1.0.0.dev1 → insightfactory_cli-1.0.0.dev4}/.github/workflows/claude.yml

@@ -16,10 +16,12 @@ on:
   pull_request_review_comment:
     types: [created]
 
-# Least privilege at the workflow level; the reusable workflow requests what it
-# needs for its own jobs.
-permissions:
-  contents: read
+# No `permissions:` block here on purpose. A called workflow may only reduce the
+# caller's grant, never raise it, and GitHub validates that at startup -- so
+# capping this to `contents: read` made every run fail with `startup_failure`
+# before any job ran. if_s_claude_review.yml declares the scopes it needs
+# (id-token/pull-requests/issues write, actions read); leaving the caller
+# unrestricted is what every other repo in the org that calls it does.
 
 jobs:
   claude:

{insightfactory_cli-1.0.0.dev1 → insightfactory_cli-1.0.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: insightfactory-cli
-Version: 1.0.0.dev1
+Version: 1.0.0.dev4
 Summary: Profile-based authentication CLI for the InsightFactory Interfaces API
 Project-URL: Homepage, https://github.com/insightfactory-ai/insightfactory-cli
 Project-URL: Repository, https://github.com/insightfactory-ai/insightfactory-cli

{insightfactory_cli-1.0.0.dev1 → insightfactory_cli-1.0.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "insightfactory-cli"
-version = "1.0.0.dev1"
+version = "1.0.0.dev4"
 description = "Profile-based authentication CLI for the InsightFactory Interfaces API"
 readme = "README.md"
 requires-python = ">=3.10"

insightfactory_cli-1.0.0.dev4/src/if_cli/cli.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Callable
+from typing import Any, NoReturn
+
+from if_cli.runtime import die, get_exit_code, handle_broken_pipe, install_broken_pipe_handlers
+
+Options = dict[str, dict[str, Any]]
+
+
+class _ArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> NoReturn:
+        # Node util.parseArgs reports "Unknown option '--flag'". argparse says
+        # "unrecognized arguments: --flag"; rewrite the common case so the two
+        # CLIs fail with the same wording.
+        if message.startswith("unrecognized arguments: "):
+            unknown = message.removeprefix("unrecognized arguments: ").split()[0]
+            die(f"Unknown option '{unknown}'")
+        die(message)
+
+
+def _option_flag_label(name: str, spec: dict[str, Any]) -> str:
+    short = spec.get("short")
+    if short:
+        return f"--{name}/-{short}"
+    return f"--{name}"
+
+
+def _resolve_short_option(
+    arg: str,
+    *,
+    options: Options,
+    short_options: dict[str, str],
+) -> tuple[str, str | None] | None:
+    """Return (option_name, inline_value) for a short-option token, or None if not an option."""
+    option_name = short_options.get(arg)
+    if option_name is not None:
+        return option_name, None
+
+    for short_flag, name in short_options.items():
+        if not arg.startswith(short_flag) or len(arg) <= len(short_flag):
+            continue
+        if options[name]["type"] == "boolean":
+            die(f"Unknown option '{arg}'")
+        return name, arg[len(short_flag) :]
+
+    return None
+
+
+def _parse_args_with_positionals(argv: list[str], *, options: Options) -> tuple[dict[str, Any], list[str]]:
+    """Parse argv allowing options and positionals in any order (Node util.parseArgs parity)."""
+    values: dict[str, Any] = {}
+    for name, spec in options.items():
+        if spec["type"] == "boolean":
+            values[name] = spec.get("default", False)
+        else:
+            values[name] = spec.get("default")
+
+    long_options = {f"--{name}": name for name in options}
+    short_options = {f"-{spec['short']}": name for name, spec in options.items() if spec.get("short") is not None}
+
+    positionals: list[str] = []
+    index = 0
+    while index < len(argv):
+        arg = argv[index]
+        if arg == "--":
+            positionals.extend(argv[index + 1 :])
+            break
+
+        option_name: str | None = None
+        inline_value: str | None = None
+
+        if arg.startswith("--"):
+            if "=" in arg:
+                flag, inline_value = arg.split("=", 1)
+                option_name = long_options.get(flag)
+                if option_name is None:
+                    die(f"Unknown option '{flag}'")
+            else:
+                option_name = long_options.get(arg)
+                if option_name is None:
+                    die(f"Unknown option '{arg}'")
+        elif arg.startswith("-") and len(arg) > 1:
+            resolved = _resolve_short_option(arg, options=options, short_options=short_options)
+            if resolved is None:
+                die(f"Unknown option '{arg}'")
+            option_name, inline_value = resolved
+        else:
+            positionals.append(arg)
+            index += 1
+            continue
+
+        spec = options[option_name]
+        if spec["type"] == "boolean":
+            if inline_value is not None:
+                die(f"argument {_option_flag_label(option_name, spec)}: does not take an argument")
+            values[option_name] = True
+            index += 1
+            continue
+
+        value = inline_value
+        if value is None:
+            if index + 1 >= len(argv):
+                die(f"argument {_option_flag_label(option_name, spec)}: expected one argument")
+            next_arg = argv[index + 1]
+            if next_arg == "--" or next_arg.startswith("-"):
+                die(f"argument {_option_flag_label(option_name, spec)}: expected one argument")
+            value = next_arg
+            index += 2
+        else:
+            index += 1
+
+        values[option_name] = value
+
+    return values, positionals
+
+
+def parse_args(
+    argv: list[str],
+    *,
+    options: Options,
+    allow_positionals: bool = False,
+) -> tuple[dict[str, Any], list[str]]:
+    """Parse argv with argparse, using the same flags as the TypeScript parseArgs specs."""
+    if allow_positionals:
+        return _parse_args_with_positionals(argv, options=options)
+
+    parser = _ArgumentParser(add_help=False, allow_abbrev=False)
+    for name, spec in options.items():
+        flags = [f"--{name}"]
+        short = spec.get("short")
+        if short:
+            flags.append(f"-{short}")
+        dest = name.replace("-", "_")
+        if spec["type"] == "boolean":
+            parser.add_argument(*flags, dest=dest, action="store_true", default=spec.get("default", False))
+        else:
+            parser.add_argument(*flags, dest=dest, default=spec.get("default"))
+    namespace = parser.parse_args(argv)
+    raw = vars(namespace)
+    values = {name: raw.get(name.replace("-", "_")) for name in options}
+    return values, []
+
+
+def run_with_handlers(run_cli: Callable[[list[str]], None], argv: list[str] | None = None) -> None:
+    install_broken_pipe_handlers()
+    try:
+        run_cli(sys.argv[1:] if argv is None else argv)
+        # Force any buffered EPIPE to raise here. Python 3.14 can keep the
+        # entire command output in the TextIOWrapper until shutdown, where an
+        # unhandled BrokenPipeError becomes exit status 120.
+        sys.stdout.flush()
+    except BrokenPipeError:
+        handle_broken_pipe()
+    except Exception as error:
+        try:
+            sys.stderr.write(f"if-cli: {error}\n")
+        except BrokenPipeError:
+            handle_broken_pipe()
+        raise SystemExit(1) from None
+    raise SystemExit(get_exit_code())

{insightfactory_cli-1.0.0.dev1 → insightfactory_cli-1.0.0.dev4}/tests/test_api_command.py

@@ -62,6 +62,64 @@ def _write_token(config_dir: str, origin: str) -> None:
     )
 
 
+def test_api_routes_accepts_profile_before_or_after_filter():
+    server, _state = _api_server("valid")
+    config_dir = create_config(f"[foundry-dev]\nhost = {server.origin}\n")
+    try:
+        after_profile = run_cli(
+            ["api", "routes", "-p", "foundry-dev", "health"],
+            env={"INSIGHTFACTORY_CONFIG_DIR": config_dir},
+        )
+        before_profile = run_cli(
+            ["api", "routes", "health", "-p", "foundry-dev"],
+            env={"INSIGHTFACTORY_CONFIG_DIR": config_dir},
+        )
+        assert after_profile.returncode == 0, after_profile.stderr
+        assert before_profile.returncode == 0, before_profile.stderr
+        assert after_profile.stdout == before_profile.stdout
+        assert "GET     /api/health" in after_profile.stdout
+    finally:
+        server.close()
+        shutil.rmtree(config_dir, ignore_errors=True)
+
+
+def test_api_describe_accepts_profile_before_or_after_method_and_path():
+    server, _state = _api_server("valid")
+    config_dir = create_config(f"[foundry-dev]\nhost = {server.origin}\n")
+    try:
+        after_profile = run_cli(
+            ["api", "describe", "-p", "foundry-dev", "GET", "/api/health"],
+            env={"INSIGHTFACTORY_CONFIG_DIR": config_dir},
+        )
+        before_profile = run_cli(
+            ["api", "describe", "GET", "/api/health", "-p", "foundry-dev"],
+            env={"INSIGHTFACTORY_CONFIG_DIR": config_dir},
+        )
+        assert after_profile.returncode == 0, after_profile.stderr
+        assert before_profile.returncode == 0, before_profile.stderr
+        assert after_profile.stdout == before_profile.stdout
+        assert '"method": "GET"' in after_profile.stdout
+        assert '"/api/health"' in after_profile.stdout
+    finally:
+        server.close()
+        shutil.rmtree(config_dir, ignore_errors=True)
+
+
+def test_api_routes_treats_tokens_after_double_dash_as_filter_text():
+    server, _state = _api_server("valid")
+    config_dir = create_config(f"[DEFAULT]\nhost = {server.origin}\n")
+    try:
+        result = run_cli(
+            ["api", "routes", "--", "-p", "ignored"],
+            env={"INSIGHTFACTORY_CONFIG_DIR": config_dir},
+        )
+        assert result.returncode == 1
+        assert "no API routes matched '-p'" in result.stderr
+    finally:
+        server.close()
+        shutil.rmtree(config_dir, ignore_errors=True)
+
+
 def test_api_routes_reports_a_missing_discovery_document():
     server, _state = _api_server("missing")
     config_dir = create_config(f"[DEFAULT]\nhost = {server.origin}\n")

{insightfactory_cli-1.0.0.dev1 → insightfactory_cli-1.0.0.dev4}/tests/test_cli.py

@@ -4,6 +4,8 @@ import json
 import shutil
 from pathlib import Path
 
+import pytest
+
 from if_cli.cli import parse_args
 from if_cli.commands.api import API_OPTIONS
 from if_cli.commands.config import CONFIG_OPTIONS
@@ -15,6 +17,80 @@ from if_cli.commands.token import TOKEN_OPTIONS
 from if_cli.runtime import CliError
 from tests.helpers import create_config, run_cli
 
+NODE_PARITY_OPTIONS = {
+    "profile": {"type": "string", "short": "p"},
+    "json": {"type": "boolean", "short": "j"},
+}
+
+
+def _default_node_parity_values() -> dict[str, object]:
+    return {"profile": None, "json": False}
+
+
+def test_parse_args_matches_node_util_parseargs_short_and_boolean_edge_cases():
+    values, positionals = parse_args(["-pprof"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == {"profile": "prof", "json": False}
+    assert positionals == []
+
+    values, positionals = parse_args(["-p=prof"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == {"profile": "=prof", "json": False}
+    assert positionals == []
+
+    values, positionals = parse_args(["-p", "prof"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == {"profile": "prof", "json": False}
+    assert positionals == []
+
+    values, positionals = parse_args(["--profile=prof"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == {"profile": "prof", "json": False}
+    assert positionals == []
+
+    values, positionals = parse_args(["--profile", "prof"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == {"profile": "prof", "json": False}
+    assert positionals == []
+
+    values, positionals = parse_args(["-j", "x"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == {"profile": None, "json": True}
+    assert positionals == ["x"]
+
+    with pytest.raises(CliError, match="Unknown option '-jx'"):
+        parse_args(["-jx"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+
+    with pytest.raises(CliError, match="argument --json/-j: does not take an argument"):
+        parse_args(["--json=false"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+
+    values, positionals = parse_args(["--json", "x"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == {"profile": None, "json": True}
+    assert positionals == ["x"]
+
+    with pytest.raises(CliError, match="argument --profile/-p: expected one argument"):
+        parse_args(["-p", "--json"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+
+    values, positionals = parse_args(["--", "-p", "lit"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == _default_node_parity_values()
+    assert positionals == ["-p", "lit"]
+
+    values, positionals = parse_args(["-"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+    assert values == _default_node_parity_values()
+    assert positionals == ["-"]
+
+    with pytest.raises(CliError, match="argument --profile/-p: expected one argument"):
+        parse_args(["-p"], options=NODE_PARITY_OPTIONS, allow_positionals=True)
+
+
+def test_parse_args_accepts_attached_profile_short_option_values():
+    values, positionals = parse_args(["-pprof"], options=API_OPTIONS, allow_positionals=True)
+    assert values["profile"] == "prof"
+    assert positionals == []
+
+    values, positionals = parse_args(["routes", "-pprof", "task"], options=API_OPTIONS, allow_positionals=True)
+    assert values["profile"] == "prof"
+    assert positionals == ["routes", "task"]
+
+
+def test_parse_args_rejects_inline_values_on_boolean_flags():
+    with pytest.raises(CliError, match="argument --json: does not take an argument"):
+        parse_args(["--json=false"], options=PROFILES_OPTIONS, allow_positionals=True)
+
 
 def test_help_prints_the_command_reference():
     result = run_cli(["--help"])
@@ -120,6 +196,73 @@ def test_api_parses_routes_and_describe_subcommands():
     assert describe == ["describe", "GET", "/api/health"]
 
 
+def test_parse_args_accepts_positionals_after_options():
+    values_after, positionals_after = parse_args(
+        ["routes", "-p", "foundry-dev", "task"],
+        options=API_OPTIONS,
+        allow_positionals=True,
+    )
+    values_before, positionals_before = parse_args(
+        ["routes", "task", "-p", "foundry-dev"],
+        options=API_OPTIONS,
+        allow_positionals=True,
+    )
+    assert values_after == values_before == {"profile": "foundry-dev", "method": None, "data": None}
+    assert positionals_after == positionals_before == ["routes", "task"]
+
+    describe_after, pos_after = parse_args(
+        ["describe", "-p", "foundry-dev", "GET", "/api/tasks"],
+        options=API_OPTIONS,
+        allow_positionals=True,
+    )
+    describe_before, pos_before = parse_args(
+        ["describe", "GET", "/api/tasks", "-p", "foundry-dev"],
+        options=API_OPTIONS,
+        allow_positionals=True,
+    )
+    assert describe_after == describe_before == {"profile": "foundry-dev", "method": None, "data": None}
+    assert pos_after == pos_before == ["describe", "GET", "/api/tasks"]
+
+    config_after, config_pos_after = parse_args(
+        ["get", "-p", "foundry-dev", "host"],
+        options=CONFIG_OPTIONS,
+        allow_positionals=True,
+    )
+    config_before, config_pos_before = parse_args(
+        ["get", "host", "-p", "foundry-dev"],
+        options=CONFIG_OPTIONS,
+        allow_positionals=True,
+    )
+    assert config_after == config_before == {"profile": "foundry-dev"}
+    assert config_pos_after == config_pos_before == ["get", "host"]
+
+
+def test_parse_args_treats_tokens_after_double_dash_as_positionals():
+    values, positionals = parse_args(
+        ["routes", "-p", "foundry-dev", "--", "-X", "GET"],
+        options=API_OPTIONS,
+        allow_positionals=True,
+    )
+    assert values == {"profile": "foundry-dev", "method": None, "data": None}
+    assert positionals == ["routes", "-X", "GET"]
+
+
+def test_parse_args_rejects_unknown_options_with_node_wording():
+    try:
+        parse_args(["routes", "--not-a-real-flag"], options=API_OPTIONS, allow_positionals=True)
+    except CliError as error:
+        assert str(error) == "Unknown option '--not-a-real-flag'"
+    else:
+        raise AssertionError("expected CliError for unknown flag")
+
+
+def test_help_is_rejected_like_the_node_cli():
+    result = run_cli(["help"])
+    assert result.returncode == 1
+    assert "unknown command 'help'" in result.stderr
+    assert "usage: if-cli <command>" in result.stderr
+
+
 def test_unknown_flags_fail_for_each_command():
     specs = [
         (LOGIN_OPTIONS, False),

{insightfactory_cli-1.0.0.dev1 → insightfactory_cli-1.0.0.dev4}/tests/test_config_command.py

@@ -19,6 +19,24 @@ PROFILE = "\n".join(
 )
 
 
+def test_config_get_accepts_profile_before_or_after_key():
+    config_dir = create_config(PROFILE)
+    try:
+        after_profile = run_cli(
+            ["config", "get", "-p", "example-dev", "host"],
+            env={"INSIGHTFACTORY_CONFIG_DIR": config_dir},
+        )
+        before_profile = run_cli(
+            ["config", "get", "host", "-p", "example-dev"],
+            env={"INSIGHTFACTORY_CONFIG_DIR": config_dir},
+        )
+        assert after_profile.returncode == 0, after_profile.stderr
+        assert before_profile.returncode == 0, before_profile.stderr
+        assert after_profile.stdout == before_profile.stdout == "https://factory.example\n"
+    finally:
+        shutil.rmtree(config_dir, ignore_errors=True)
+
+
 def test_config_get_falls_back_to_the_derived_audience_and_default_callback_port():
     config_dir = create_config(PROFILE)
     try:

insightfactory_cli-1.0.0.dev1/src/if_cli/cli.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import sys
-from collections.abc import Callable
-from typing import Any, NoReturn
-
-from if_cli.runtime import die, get_exit_code, handle_broken_pipe, install_broken_pipe_handlers
-
-Options = dict[str, dict[str, Any]]
-
-
-class _ArgumentParser(argparse.ArgumentParser):
-    def error(self, message: str) -> NoReturn:
-        # Node util.parseArgs reports "Unknown option '--flag'". argparse says
-        # "unrecognized arguments: --flag"; rewrite the common case so the two
-        # CLIs fail with the same wording.
-        if message.startswith("unrecognized arguments: "):
-            unknown = message.removeprefix("unrecognized arguments: ").split()[0]
-            die(f"Unknown option '{unknown}'")
-        die(message)
-
-
-def parse_args(
-    argv: list[str],
-    *,
-    options: Options,
-    allow_positionals: bool = False,
-) -> tuple[dict[str, Any], list[str]]:
-    """Parse argv with argparse, using the same flags as the TypeScript parseArgs specs."""
-    parser = _ArgumentParser(add_help=False, allow_abbrev=False)
-    for name, spec in options.items():
-        flags = [f"--{name}"]
-        short = spec.get("short")
-        if short:
-            flags.append(f"-{short}")
-        dest = name.replace("-", "_")
-        if spec["type"] == "boolean":
-            parser.add_argument(*flags, dest=dest, action="store_true", default=spec.get("default", False))
-        else:
-            parser.add_argument(*flags, dest=dest, default=spec.get("default"))
-    if allow_positionals:
-        parser.add_argument("positionals", nargs="*")
-    namespace = parser.parse_args(argv)
-    raw = vars(namespace)
-    values = {name: raw.get(name.replace("-", "_")) for name in options}
-    if allow_positionals:
-        return values, list(raw.get("positionals") or [])
-    return values, []
-
-
-def run_with_handlers(run_cli: Callable[[list[str]], None], argv: list[str] | None = None) -> None:
-    install_broken_pipe_handlers()
-    try:
-        run_cli(sys.argv[1:] if argv is None else argv)
-        # Force any buffered EPIPE to raise here. Python 3.14 can keep the
-        # entire command output in the TextIOWrapper until shutdown, where an
-        # unhandled BrokenPipeError becomes exit status 120.
-        sys.stdout.flush()
-    except BrokenPipeError:
-        handle_broken_pipe()
-    except Exception as error:
-        try:
-            sys.stderr.write(f"if-cli: {error}\n")
-        except BrokenPipeError:
-            handle_broken_pipe()
-        raise SystemExit(1) from None
-    raise SystemExit(get_exit_code())