alice-cli 0.1.0__py3-none-any.whl

alice_cli/.kiro/settings/lsp.json

@@ -0,0 +1,198 @@
+{
+  "languages": {
+    "rust": {
+      "name": "rust-analyzer",
+      "command": "rust-analyzer",
+      "args": [],
+      "file_extensions": [
+        "rs"
+      ],
+      "project_patterns": [
+        "Cargo.toml"
+      ],
+      "exclude_patterns": [
+        "**/target/**"
+      ],
+      "multi_workspace": false,
+      "initialization_options": {
+        "cargo": {
+          "buildScripts": {
+            "enable": true
+          }
+        },
+        "diagnostics": {
+          "enable": true,
+          "enableExperimental": true
+        },
+        "workspace": {
+          "symbol": {
+            "search": {
+              "scope": "workspace"
+            }
+          }
+        }
+      },
+      "request_timeout_secs": 60
+    },
+    "ruby": {
+      "name": "solargraph",
+      "command": "solargraph",
+      "args": [
+        "stdio"
+      ],
+      "file_extensions": [
+        "rb"
+      ],
+      "project_patterns": [
+        "Gemfile",
+        "Rakefile"
+      ],
+      "exclude_patterns": [
+        "**/vendor/**",
+        "**/tmp/**"
+      ],
+      "multi_workspace": false,
+      "initialization_options": {},
+      "request_timeout_secs": 60
+    },
+    "cpp": {
+      "name": "clangd",
+      "command": "clangd",
+      "args": [
+        "--background-index"
+      ],
+      "file_extensions": [
+        "cpp",
+        "cc",
+        "cxx",
+        "c",
+        "h",
+        "hpp",
+        "hxx"
+      ],
+      "project_patterns": [
+        "CMakeLists.txt",
+        "compile_commands.json",
+        "Makefile"
+      ],
+      "exclude_patterns": [
+        "**/build/**",
+        "**/cmake-build-**/**"
+      ],
+      "multi_workspace": false,
+      "initialization_options": {},
+      "request_timeout_secs": 60
+    },
+    "python": {
+      "name": "pyright",
+      "command": "pyright-langserver",
+      "args": [
+        "--stdio"
+      ],
+      "file_extensions": [
+        "py"
+      ],
+      "project_patterns": [
+        "pyproject.toml",
+        "setup.py",
+        "requirements.txt",
+        "pyrightconfig.json"
+      ],
+      "exclude_patterns": [
+        "**/__pycache__/**",
+        "**/venv/**",
+        "**/.venv/**",
+        "**/.pytest_cache/**"
+      ],
+      "multi_workspace": false,
+      "initialization_options": {},
+      "request_timeout_secs": 60
+    },
+    "go": {
+      "name": "gopls",
+      "command": "gopls",
+      "args": [],
+      "file_extensions": [
+        "go"
+      ],
+      "project_patterns": [
+        "go.mod",
+        "go.sum"
+      ],
+      "exclude_patterns": [
+        "**/vendor/**"
+      ],
+      "multi_workspace": false,
+      "initialization_options": {
+        "usePlaceholders": true,
+        "completeUnimported": true
+      },
+      "request_timeout_secs": 60
+    },
+    "java": {
+      "name": "jdtls",
+      "command": "jdtls",
+      "args": [],
+      "file_extensions": [
+        "java"
+      ],
+      "project_patterns": [
+        "pom.xml",
+        "build.gradle",
+        "build.gradle.kts",
+        ".project"
+      ],
+      "exclude_patterns": [
+        "**/target/**",
+        "**/build/**",
+        "**/.gradle/**"
+      ],
+      "multi_workspace": false,
+      "initialization_options": {
+        "settings": {
+          "java": {
+            "compile": {
+              "nullAnalysis": {
+                "mode": "automatic"
+              }
+            },
+            "configuration": {
+              "annotationProcessing": {
+                "enabled": true
+              }
+            }
+          }
+        }
+      },
+      "request_timeout_secs": 60
+    },
+    "typescript": {
+      "name": "typescript-language-server",
+      "command": "typescript-language-server",
+      "args": [
+        "--stdio"
+      ],
+      "file_extensions": [
+        "ts",
+        "js",
+        "tsx",
+        "jsx"
+      ],
+      "project_patterns": [
+        "package.json",
+        "tsconfig.json"
+      ],
+      "exclude_patterns": [
+        "**/node_modules/**",
+        "**/dist/**"
+      ],
+      "multi_workspace": false,
+      "initialization_options": {
+        "preferences": {
+          "disableSuggestions": false
+        }
+      },
+      "request_timeout_secs": 60
+    }
+  }
+}

alice_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

alice_cli/auth.py

@@ -0,0 +1,64 @@
+"""JHED detection from STS/SSO caller identity."""
+
+from __future__ import annotations
+
+import boto3
+from botocore.exceptions import BotoCoreError, ClientError
+
+from alice_cli import personality
+from alice_cli.errors import AuthError
+from alice_cli.models import JHEDResult
+
+
+def detect_identity_from_key(access_key: str | None) -> str:
+    """Extract a display name from the Bedrock access key alias.
+
+    The ``BEDROCK_ACCESS_KEY`` (``service_credential_alias``) follows the
+    pattern ``BedrockAPIKey-<JHED>-at-<ACCOUNT>``.  We extract the JHED
+    portion when the pattern matches, otherwise return the raw value.
+
+    Returns ``"unknown"`` when the access key is empty / absent.
+    """
+    if not access_key:
+        return "unknown"
+
+    # Pattern: BedrockAPIKey-<jhed>-at-<account_id>
+    if access_key.startswith("BedrockAPIKey-") and "-at-" in access_key:
+        return access_key.removeprefix("BedrockAPIKey-").split("-at-", maxsplit=1)[0]
+
+    return access_key
+
+
+def detect_jhed(profile: str | None, region: str) -> JHEDResult:
+    """Call STS get-caller-identity and extract the JHED from the ARN session name.
+
+    Args:
+        profile: AWS CLI profile name, or None if not provided.
+        region: AWS region to use for the STS call.
+
+    Returns:
+        JHEDResult with jhed, session_name, and full ARN.
+
+    Raises:
+        AuthError: If no profile is provided, STS call fails, or JHED cannot be extracted.
+    """
+    if profile is None:
+        raise AuthError(personality.error_no_profile())
+
+    try:
+        session = boto3.Session(profile_name=profile, region_name=region)
+        sts = session.client("sts")
+        identity = sts.get_caller_identity()
+    except (ClientError, BotoCoreError):
+        raise AuthError(personality.error_sso_expired(profile))
+
+    arn: str = identity["Arn"]
+    # ARN format: arn:aws:sts::ACCOUNT:assumed-role/ROLE/session_name
+    session_name = arn.rsplit("/", maxsplit=1)[-1]
+
+    if "@" not in session_name:
+        raise AuthError(personality.error_jhed_extraction(session_name))
+
+    jhed = session_name.split("@", maxsplit=1)[0]
+
+    return JHEDResult(jhed=jhed, session_name=session_name, arn=arn)

alice_cli/cli.py

@@ -0,0 +1,98 @@
+"""Top-level Click group and global options for the alice CLI."""
+
+from __future__ import annotations
+
+import click
+
+from alice_cli import __version__
+from alice_cli.config import resolve_config
+from alice_cli.errors import AliceCLIError
+from alice_cli.models import CLIConfig
+
+
+def launch_tui(config: CLIConfig) -> None:
+    """Launch the interactive TUI mode.
+
+    Lazily imports ``textual`` so CLI-only users never pay for the dependency.
+    Raises :class:`AliceCLIError` if the ``textual`` extra is not installed.
+    """
+    try:
+        from alice_cli.tui.app import AliceTUIApp
+    except ImportError:
+        raise AliceCLIError(
+            "TUI mode needs the 'textual' package.\n"
+            "  Install it with: poetry install --extras tui"
+        )
+    app = AliceTUIApp(config)
+    app.run()
+
+
+@click.group(invoke_without_command=True)
+@click.option("--profile", envvar="AWS_PROFILE", default=None, help="AWS CLI profile")
+@click.option("--region", default=None, help="AWS region (default: us-east-1)")
+@click.option("--namespace", default=None, help="Resource namespace (default: drcc)")
+@click.option("--environment", default=None, help="Deployment environment (default: ai)")
+@click.option("--api-key", envvar="BEDROCK_SECRET_KEY", default=None, help="Bedrock API key (skips SSO/Secrets Manager; or set BEDROCK_SECRET_KEY)")
+@click.option("--quiet", is_flag=True, help="Suppress banner and status messages")
+@click.option("--tui", is_flag=True, help="Launch interactive TUI mode")
+@click.version_option(version=__version__)
+@click.pass_context
+def cli(
+    ctx: click.Context,
+    profile: str | None,
+    region: str | None,
+    namespace: str | None,
+    environment: str | None,
+    api_key: str | None,
+    quiet: bool,
+    tui: bool,
+) -> None:
+    """ALiCE — Your AI research companion at Johns Hopkins."""
+    ctx.ensure_object(dict)
+    ctx.obj["config"] = resolve_config(
+        profile, region, namespace, environment, quiet, api_key
+    )
+    if tui:
+        launch_tui(ctx.obj["config"])
+        ctx.exit()
+
+
+from alice_cli.commands.appraise import appraise_cmd  # noqa: E402
+from alice_cli.commands.auth import auth  # noqa: E402
+from alice_cli.commands.batch import batch_cmd  # noqa: E402
+from alice_cli.commands.chat import chat_cmd  # noqa: E402
+from alice_cli.commands.compare import compare_cmd  # noqa: E402
+from alice_cli.commands.compose import compose  # noqa: E402
+from alice_cli.commands.config_cmd import config_cmd  # noqa: E402
+from alice_cli.commands.diagnose import diagnose_cmd  # noqa: E402
+from alice_cli.commands.dialog import dialog_cmd  # noqa: E402
+from alice_cli.commands.get_key import get_key  # noqa: E402
+from alice_cli.commands.get_secret import get_secret  # noqa: E402
+from alice_cli.commands.invoke import invoke_cmd  # noqa: E402
+from alice_cli.commands.list_aliases import list_aliases  # noqa: E402
+from alice_cli.commands.list_models import list_models  # noqa: E402
+from alice_cli.commands.list_secrets import list_secrets  # noqa: E402
+from alice_cli.commands.recall import recall_cmd  # noqa: E402
+from alice_cli.commands.run import run_cmd  # noqa: E402
+from alice_cli.commands.status import status  # noqa: E402
+from alice_cli.commands.summarize import summarize_cmd  # noqa: E402
+
+cli.add_command(appraise_cmd)
+cli.add_command(auth)
+cli.add_command(batch_cmd)
+cli.add_command(chat_cmd)
+cli.add_command(compare_cmd)
+cli.add_command(compose)
+cli.add_command(config_cmd)
+cli.add_command(diagnose_cmd)
+cli.add_command(dialog_cmd)
+cli.add_command(get_key)
+cli.add_command(get_secret)
+cli.add_command(invoke_cmd)
+cli.add_command(list_aliases)
+cli.add_command(list_models)
+cli.add_command(list_secrets)
+cli.add_command(recall_cmd)
+cli.add_command(run_cmd)
+cli.add_command(status)
+cli.add_command(summarize_cmd)

alice_cli/commands/__init__.py

@@ -0,0 +1 @@
+

alice_cli/commands/appraise.py

@@ -0,0 +1,213 @@
+"""alice appraise — Token usage and cost reporting from the Cloud Locker."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+import click
+from rich.table import Table
+
+from alice_cli import personality
+from alice_cli.auth import detect_identity_from_key, detect_jhed
+from alice_cli.commands.recall import filter_entries
+from alice_cli.console import (
+    err_console,
+    print_banner,
+    print_status,
+    print_success,
+    spinner,
+)
+from alice_cli.locker import CloudLocker
+from alice_cli.models import IndexEntry, model_help_text
+from alice_cli.pricing import estimate_cost, format_cost
+
+
+@click.command("appraise")
+@click.option("--since", default=None, help="Include sessions on or after this date (YYYY-MM-DD)")
+@click.option("--model", default=None, help="Filter by model alias or ID (substring match)")
+@click.option(
+    "--detailed",
+    is_flag=True,
+    default=False,
+    help="Show per-session token counts instead of per-model aggregates",
+)
+@click.pass_context
+def appraise_cmd(
+    ctx: click.Context,
+    since: str | None,
+    model: str | None,
+    detailed: bool,
+) -> None:
+    """Show token usage and approximate costs for past sessions.
+
+    \b
+    Examples:
+        alice appraise
+        alice appraise --since 2025-01-01
+        alice appraise --model sonnet
+        alice appraise --detailed
+        alice appraise --since 2025-06-01 --model haiku --detailed
+    """
+    config = ctx.obj["config"]
+
+    print_banner(personality.BANNER, config.quiet)
+
+    # ── Authenticate ──────────────────────────────────────────────────
+    jhed: str
+
+    if config.bedrock_secret_key and not config.profile:
+        jhed = detect_identity_from_key(config.bedrock_access_key)
+        print_status(personality.status_using_api_key(jhed), config.quiet)
+    else:
+        with spinner(personality.status_detecting_identity(), config.quiet):
+            result = detect_jhed(config.profile, config.region)
+        jhed = result.jhed
+        print_status(personality.status_identity_detected(jhed), config.quiet)
+
+    locker = CloudLocker(config=config, jhed=jhed, bucket="jh-drcc-alice-memory")
+
+    # ── Load index and filter ─────────────────────────────────────────
+    with spinner("Loading session index…", config.quiet):
+        index = locker.load_index()
+
+    # Reuse recall's filter_entries for --since and --model filtering.
+    # We pass a very large limit so nothing is truncated.
+    filtered = filter_entries(
+        index.entries,
+        since=since,
+        model=model,
+        limit=0,  # 0 means no limit in filter_entries
+    )
+
+    # Keep only entries that have token usage data
+    entries_with_tokens = [e for e in filtered if e.tokens is not None]
+
+    # If we matched sessions but none have tokens, try backfilling from
+    # the full session records stored in S3 / local cache.
+    if filtered and not entries_with_tokens:
+        with spinner("Backfilling token data from session records…", config.quiet):
+            filtered, filled = locker.backfill_tokens(filtered)
+        if filled:
+            err_console.print(f"  [dim]Backfilled token data for {filled} session(s).[/dim]")
+        entries_with_tokens = [e for e in filtered if e.tokens is not None]
+
+    if not entries_with_tokens:
+        if filtered:
+            err_console.print(
+                f"  [dim]Found {len(filtered)} session(s) but none have token usage recorded.[/dim]"
+            )
+        else:
+            err_console.print("  [dim]No matching sessions found.[/dim]")
+        return
+
+    if detailed:
+        _display_detailed(entries_with_tokens, config.quiet)
+    else:
+        _display_aggregated(entries_with_tokens, config.quiet)
+
+
+def _display_aggregated(entries: list[IndexEntry], quiet: bool) -> None:
+    """Display per-model aggregate token usage with a summary row."""
+    # Aggregate by model
+    model_stats: dict[str, list[int]] = defaultdict(lambda: [0, 0, 0])
+
+    for entry in entries:
+        assert entry.tokens is not None
+        stats = model_stats[entry.model]
+        stats[0] += entry.tokens.input
+        stats[1] += entry.tokens.output
+        stats[2] += entry.tokens.total
+
+    table = Table(title="Token Usage by Model", show_lines=False)
+    table.add_column("Model", style="green")
+    table.add_column("Input Tokens", style="cyan", justify="right")
+    table.add_column("Output Tokens", style="cyan", justify="right")
+    table.add_column("Total Tokens", style="cyan", justify="right")
+    table.add_column("Est. Cost", style="yellow", justify="right")
+
+    total_input = 0
+    total_output = 0
+    total_total = 0
+    total_cost = 0.0
+
+    for model_name, (inp, out, tot) in sorted(model_stats.items()):
+        cost = estimate_cost(model_name, inp, out)
+        total_input += inp
+        total_output += out
+        total_total += tot
+        total_cost += cost
+        table.add_row(
+            model_name,
+            f"{inp:,}",
+            f"{out:,}",
+            f"{tot:,}",
+            format_cost(cost),
+        )
+
+    # Summary row
+    table.add_section()
+    table.add_row(
+        "[bold]Total[/bold]",
+        f"[bold]{total_input:,}[/bold]",
+        f"[bold]{total_output:,}[/bold]",
+        f"[bold]{total_total:,}[/bold]",
+        f"[bold]{format_cost(total_cost)}[/bold]",
+    )
+
+    err_console.print(table)
+    print_success(
+        f"{len(entries)} session(s), {total_total:,} tokens, {format_cost(total_cost)}",
+        quiet,
+    )
+
+
+def _display_detailed(entries: list[IndexEntry], quiet: bool) -> None:
+    """Display per-session token usage with a summary row."""
+    table = Table(title="Token Usage by Session", show_lines=False)
+    table.add_column("Timestamp", style="cyan", no_wrap=True)
+    table.add_column("Type", style="magenta")
+    table.add_column("Model", style="green")
+    table.add_column("Input Tokens", style="cyan", justify="right")
+    table.add_column("Output Tokens", style="cyan", justify="right")
+    table.add_column("Total Tokens", style="cyan", justify="right")
+    table.add_column("Est. Cost", style="yellow", justify="right")
+
+    total_input = 0
+    total_output = 0
+    total_total = 0
+    total_cost = 0.0
+
+    for entry in entries:
+        assert entry.tokens is not None
+        cost = estimate_cost(entry.model, entry.tokens.input, entry.tokens.output)
+        total_input += entry.tokens.input
+        total_output += entry.tokens.output
+        total_total += entry.tokens.total
+        total_cost += cost
+        table.add_row(
+            entry.timestamp[:19],
+            entry.type,
+            entry.model,
+            f"{entry.tokens.input:,}",
+            f"{entry.tokens.output:,}",
+            f"{entry.tokens.total:,}",
+            format_cost(cost),
+        )
+
+    # Summary row
+    table.add_section()
+    table.add_row(
+        "[bold]Total[/bold]",
+        "",
+        "",
+        f"[bold]{total_input:,}[/bold]",
+        f"[bold]{total_output:,}[/bold]",
+        f"[bold]{total_total:,}[/bold]",
+        f"[bold]{format_cost(total_cost)}[/bold]",
+    )
+
+    err_console.print(table)
+    print_success(
+        f"{len(entries)} session(s), {total_total:,} tokens, {format_cost(total_cost)}",
+        quiet,
+    )