asky-cli 0.1.7__py3-none-any.whl

asky/__init__.py

@@ -0,0 +1,7 @@
+"""asky - AI-powered web search CLI with LLM tool-calling capabilities."""
+
+__version__ = "0.1.0"
+
+from asky.cli import main
+
+__all__ = ["main", "__version__"]

asky/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m asky`."""
+
+from asky.cli import main
+
+if __name__ == "__main__":
+    main()

asky/banner.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+Cute Terminal Icon - ASCII Art
+"""
+
+from rich.console import Console
+from rich.text import Text
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+
+# Color shortcuts for templates
+G = "bold #39ff14"  # neon green (eyes)
+P = "#ff8fa3"  # pink (blush)
+D = "dim"  # dim (border)
+N = "#39ff14"  # nose (not bold = dimmer)
+
+# Metallic shiny effect colors
+M1 = "bold #ffffff"  # bright highlight
+M2 = "bold #c0c0c0"  # silver
+M3 = "#a0a0a0"  # medium gray
+M4 = "#707070"  # shadow
+
+
+def display(lines):
+    """Display lines with markup"""
+    console = Console()
+    console.print()
+    for line in lines:
+        console.print(Text.from_markup(line))
+    console.print()
+
+
+def mini():
+    """Mini version"""
+    display(
+        [
+            f"[{G}]  ∩     ∩[/{G}]  [{M1}]a[/{M1}]",
+            f"[{D}] ╭┴─────┴╮[/{D}] [{M2}]s[/{M2}]",
+            f"[{D}] │[/{D}] [{G}]▷[/{G}] [{D}][{N}]ω[/{N}][/{D}] [{G}]_[/{G}] [{D}]│[/{D}] [{M3}]k[/{M3}]",
+            f"[{D}] │[/{D}] [{P}]◠[/{P}]   [{P}]◠[/{P}] [{D}]│[/{D}] [{M4}]y[/{M4}]",
+            f"[{D}] ╰───────╯[/{D}] ",
+        ]
+    )
+
+
+def get_banner(
+    model_alias: str,
+    model_id: str,
+    sum_alias: str,
+    sum_id: str,
+    default_model: str,
+    search_provider: str,
+    model_ctx: int,
+    sum_ctx: int,
+    max_turns: int,
+    db_count: int,
+) -> Panel:
+    """Create a side-by-side banner with an icon and configuration info in two columns."""
+    icon_lines = [
+        f"[{G}]  ∩     ∩[/{G}]  [{M1}]a[/{M1}]",
+        f"[{D}] ╭┴─────┴╮[/{D}] [{M2}]s[/{M2}]",
+        f"[{D}] │[/{D}] [{G}]▷[/{G}] [{D}][{N}]ω[/{N}][/{D}] [{G}]_[/{G}] [{D}]│[/{D}] [{M3}]k[/{M3}]",
+        f"[{D}] │[/{D}] [{P}]◠[/{P}]   [{P}]◠[/{P}] [{D}]│[/{D}] [{M4}]y[/{M4}]",
+        f"[{D}] ╰───────╯[/{D}] ",
+    ]
+    icon_text = Text.from_markup("\n".join(icon_lines))
+
+    # --- Configuration Columns ---
+    col1 = Table.grid(padding=(0, 1))
+    col1.add_column(justify="left", style="bold cyan")
+    col1.add_column(justify="left")
+    col1.add_row(
+        " Main Model :", f" [white]{model_alias}[/white] ([dim]{model_id}[/dim])"
+    )
+    col1.add_row(" Summarizer :", f" [white]{sum_alias}[/white] ([dim]{sum_id}[/dim])")
+    col1.add_row(" Default    :", f" [white]{default_model}[/white]")
+
+    col2 = Table.grid(padding=(0, 1))
+    col2.add_column(justify="left", style="bold cyan")
+    col2.add_column(justify="left")
+    col2.add_row(" Search     :", f" [white]{search_provider}[/white]")
+    col2.add_row(
+        " Context    :",
+        f" [white]{model_ctx:,}[/white]/[white]{sum_ctx:,}[/white] [dim]tokens[/dim]",
+    )
+    col2.add_row(
+        " System     :",
+        f" [white]{max_turns}[/white] [dim]turns[/dim] | [white]{db_count}[/white] [dim]records[/dim]",
+    )
+
+    info_layout = Table.grid(padding=(0, 3))
+    info_layout.add_column()
+    info_layout.add_column()
+    info_layout.add_row(col1, col2)
+
+    # --- Main Layout ---
+    layout_table = Table.grid(padding=(0, 2))
+    layout_table.add_column()
+    layout_table.add_column(ratio=1)
+    layout_table.add_row(icon_text, info_layout)
+
+    return Panel(layout_table, box=box.ROUNDED, border_style="dim", padding=(0, 1))
+
+
+if __name__ == "__main__":
+    mini()
+    # Test get_banner
+    console = Console()
+    console.print(
+        get_banner(
+            "gf",
+            "gemini-flash-latest",
+            "lfm",
+            "llama3",
+            "gf",
+            "searxng",
+            1000000,
+            4096,
+            20,
+            123,
+        )
+    )

asky/cli/__init__.py

@@ -0,0 +1,11 @@
+"""CLI package for asky."""
+
+from asky.cli.history import (
+    show_history_command as show_history,
+    print_answers_command as print_answers,
+    handle_cleanup_command as handle_cleanup,
+)
+from asky.cli.prompts import list_prompts_command as list_prompts
+from asky.cli.chat import run_chat, load_context, build_messages
+from asky.cli.utils import expand_query_text, print_config
+from asky.cli.main import main, parse_args, handle_print_answer_implicit

asky/cli/chat.py

@@ -0,0 +1,172 @@
+"""Chat implementation for asky CLI."""
+
+import sys
+import argparse
+from typing import List, Dict, Any, Optional
+
+from asky.config import (
+    MODELS,
+    SUMMARIZATION_MODEL,
+    QUERY_EXPANSION_MAX_DEPTH,
+)
+from asky.core import (
+    ConversationEngine,
+    create_default_tool_registry,
+    create_deep_dive_tool_registry,
+    UsageTracker,
+    construct_system_prompt,
+    generate_summaries,
+)
+from asky.storage import (
+    get_history,
+    get_interaction_context,
+    save_interaction,
+)
+
+
+def load_context(continue_ids: str, summarize: bool) -> Optional[str]:
+    """Load context from previous interactions."""
+    try:
+        raw_ids = [x.strip() for x in continue_ids.split(",")]
+        resolved_ids = []
+        relative_indices = []
+
+        for raw_id in raw_ids:
+            if raw_id.startswith("~"):
+                try:
+                    rel_val = int(raw_id[1:])
+                    if rel_val < 1:
+                        print(f"Error: Relative ID must be >= 1 (got {raw_id})")
+                        return None
+                    relative_indices.append(rel_val)
+                except ValueError:
+                    print(f"Error: Invalid relative ID format: {raw_id}")
+                    return None
+            else:
+                resolved_ids.append(int(raw_id))
+
+        if relative_indices:
+            max_depth = max(relative_indices)
+            history_rows = get_history(limit=max_depth)
+
+            for rel_val in relative_indices:
+                list_index = rel_val - 1
+                if list_index < len(history_rows):
+                    real_id = history_rows[list_index][0]
+                    resolved_ids.append(real_id)
+                else:
+                    print(
+                        f"Error: Relative ID {rel_val} is out of range (only {len(history_rows)} records available)."
+                    )
+                    return None
+
+        resolved_ids = sorted(list(set(resolved_ids)))
+        full_content = not summarize
+        context_str = get_interaction_context(resolved_ids, full=full_content)
+        if context_str:
+            print(f"\n[Loaded context from IDs: {', '.join(map(str, resolved_ids))}]")
+        return context_str
+    except ValueError:
+        print(
+            "Error: Invalid format for -c/--continue-chat. Use comma-separated integers or ~N for relative."
+        )
+        return None
+
+
+def build_messages(
+    args: argparse.Namespace, context_str: str, query_text: str
+) -> List[Dict[str, str]]:
+    """Build the initial message list for the conversation."""
+    messages = [
+        {
+            "role": "system",
+            "content": construct_system_prompt(
+                args.deep_research, args.deep_dive, args.force_search
+            ),
+        },
+    ]
+
+    if context_str:
+        messages.append(
+            {
+                "role": "user",
+                "content": f"Context from previous queries:\n{context_str}\n\nMy new query is below.",
+            }
+        )
+
+    messages.append({"role": "user", "content": query_text})
+    return messages
+
+
+def run_chat(args: argparse.Namespace, query_text: str) -> None:
+    """Run the chat conversation flow."""
+    # Handle Context
+    context_str = ""
+    if args.continue_ids:
+        context_str = load_context(args.continue_ids, args.summarize)
+        if context_str is None:
+            return
+
+    messages = build_messages(args, context_str, query_text)
+
+    # Initialize Components
+    usage_tracker = UsageTracker()
+
+    if args.deep_dive:
+        registry = create_deep_dive_tool_registry()
+    else:
+        registry = create_default_tool_registry()
+
+    model_config = MODELS[args.model]
+
+    engine = ConversationEngine(
+        model_config=model_config,
+        tool_registry=registry,
+        summarize=args.summarize,
+        verbose=args.verbose,
+        usage_tracker=usage_tracker,
+        open_browser=args.open,
+        deep_dive=args.deep_dive,
+    )
+
+    # Run loop
+    try:
+        final_answer = engine.run(messages)
+
+        # Save Interaction
+        if final_answer:
+            print("\n[Saving interaction...]")
+            query_summary, answer_summary = generate_summaries(
+                query_text, final_answer, usage_tracker=usage_tracker
+            )
+            save_interaction(
+                query_text, final_answer, args.model, query_summary, answer_summary
+            )
+
+        # Send Email if requested
+        if final_answer and getattr(args, "mail_recipients", None):
+            from asky.email_sender import send_email
+
+            recipients = [x.strip() for x in args.mail_recipients.split(",")]
+            email_subject = args.subject or f"asky Result: {query_text[:50]}"
+            send_email(recipients, email_subject, final_answer)
+
+    except KeyboardInterrupt:
+        print("\nAborted by user.")
+    except Exception as e:
+        print(f"\nAn error occurred: {e}")
+        if args.verbose:
+            import traceback
+
+            traceback.print_exc()
+    finally:
+        # Report usage
+        if usage_tracker.usage:
+            print("\n=== SESSION TOKEN USAGE ===")
+            total_session_tokens = 0
+            for m_alias, tokens in usage_tracker.usage.items():
+                print(f"  {m_alias:<15}: {tokens:,} tokens")
+                total_session_tokens += tokens
+            print("-" * 30)
+            print(f"  {'TOTAL':<15}: {total_session_tokens:,} tokens")
+            print("===========================\n")

asky/cli/history.py

@@ -0,0 +1,98 @@
+"""History-related CLI commands for asky."""
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+from asky.core import is_markdown
+from asky.rendering import render_to_browser
+from asky.storage import (
+    get_history,
+    get_interaction_context,
+    cleanup_db,
+)
+
+
+def show_history_command(history_arg: int) -> None:
+    """Display recent query history."""
+    limit = history_arg if history_arg > 0 else 10
+    rows = get_history(limit)
+    print(f"\nLast {len(rows)} Queries:")
+    print("-" * 60)
+    for row in rows:
+        rid = row[0]
+        query = row[2]
+        query_summary = row[3]
+        answer_summary = row[4]
+
+        display_query = query_summary if query_summary else query
+        a_sum = answer_summary if answer_summary else ""
+
+        if len(display_query) > 50:
+            display_query = display_query[:47] + "..."
+        if len(a_sum) > 50:
+            a_sum = a_sum[:47] + "..."
+
+        print(f"{rid:<4} | {display_query:<50} | {a_sum:<50}")
+    print("-" * 60)
+
+
+def print_answers_command(
+    ids_str: str,
+    summarize: bool,
+    open_browser: bool = False,
+    mail_recipients: str = None,
+    subject: str = None,
+) -> None:
+    """Print answers for specific history IDs."""
+    try:
+        ids = [int(x.strip()) for x in ids_str.split(",")]
+    except ValueError:
+        print("Error: Invalid ID format. Use comma-separated integers.")
+        return
+
+    context = get_interaction_context(ids, full=not summarize)
+    if not context:
+        print("No records found for the given IDs.")
+        return
+
+    print(f"\n[Retrieving answers for IDs: {ids_str}]\n")
+    print("-" * 60)
+    if is_markdown(context):
+        console = Console()
+        console.print(Markdown(context))
+    else:
+        print(context)
+    print("-" * 60)
+
+    if open_browser:
+        render_to_browser(context)
+
+    if mail_recipients:
+        from asky.email_sender import send_email
+
+        recipients = [x.strip() for x in mail_recipients.split(",")]
+        # Use provided subject or default
+        email_subject = subject or f"asky History: {ids_str}"
+        send_email(recipients, email_subject, context)
+
+
+def handle_cleanup_command(args) -> bool:
+    """Handle cleanup-db flag."""
+    if args.cleanup_db or (args.cleanup_db is None and getattr(args, "all", False)):
+        if args.all:
+            count = cleanup_db(delete_all=True)
+            print(f"Deleted all {count} records from history.")
+        elif "-" in args.cleanup_db or "," in args.cleanup_db:
+            count = cleanup_db(ids=args.cleanup_db)
+            print(f"Deleted {count} records from history.")
+        else:
+            try:
+                days = int(args.cleanup_db)
+                count = cleanup_db(days=days)
+                print(f"Deleted {count} records older than {days} days.")
+            except ValueError:
+                print(
+                    "Error: Invalid cleanup format. Use days (int), range (start-end), or list (1,2,3)."
+                )
+        return True
+    return False

asky/cli/main.py

@@ -0,0 +1,230 @@
+"""Command-line interface for asky."""
+
+import argparse
+import re
+import sys
+
+from rich.console import Console
+
+from asky.config import (
+    DEFAULT_MODEL,
+    MODELS,
+    SUMMARIZATION_MODEL,
+    SEARCH_PROVIDER,
+    DEFAULT_CONTEXT_SIZE,
+    MAX_TURNS,
+    QUERY_SUMMARY_MAX_CHARS,
+    ANSWER_SUMMARY_MAX_CHARS,
+    LOG_LEVEL,
+    LOG_FILE,
+)
+from asky.banner import get_banner
+from asky.logger import setup_logging
+from asky.storage import init_db, get_db_record_count
+from . import history, prompts, chat, utils
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Tool-calling CLI with model selection.",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument(
+        "-m",
+        "--model",
+        default=DEFAULT_MODEL,
+        choices=MODELS.keys(),
+        help="Select the model alias",
+    )
+    parser.add_argument(
+        "-d",
+        "--deep-research",
+        nargs="?",
+        type=int,
+        const=5,
+        default=0,
+        help="Enable deep research mode (optional: specify min number of queries, default 5)",
+    )
+    parser.add_argument(
+        "-dd",
+        "--deep-dive",
+        action="store_true",
+        help="Enable deep dive mode (extracts links and encourages reading more pages from same domain)",
+    )
+    parser.add_argument(
+        "-c",
+        "--continue-chat",
+        dest="continue_ids",
+        help="Continue conversation with context from specific history IDs (comma-separated, e.g. '1,2').",
+    )
+    parser.add_argument(
+        "-s",
+        "--summarize",
+        action="store_true",
+        help="Enable summarize mode (summarizes URL content and uses summaries for chat context)",
+    )
+    parser.add_argument(
+        "-fs",
+        "--force-search",
+        action="store_true",
+        help="Force the model to use web search (default: False).\n"
+        "Helpful for avoiding hallucinations with small models",
+    )
+    parser.add_argument(
+        "--cleanup-db",
+        nargs="?",
+        const="interactive",
+        help="Delete history records. usage: --cleanup-db [ID|ID-ID|ID,ID] or --cleanup-db --all",
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Used with --cleanup-db to delete ALL history.",
+    )
+    parser.add_argument(
+        "-H",
+        "--history",
+        nargs="?",
+        type=int,
+        const=10,
+        help="Show last N queries and answer summaries (default 10).\n"
+        "Use with --print-answer to print the full answer(s).",
+    )
+    parser.add_argument(
+        "-pa",
+        "--print-answer",
+        dest="print_ids",
+        help="Print the answer(s) for specific history IDs (comma-separated).",
+    )
+    parser.add_argument(
+        "-p",
+        "--prompts",
+        action="store_true",
+        help="List all configured user prompts.",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output (prints config and LLM inputs).",
+    )
+    parser.add_argument(
+        "-o",
+        "--open",
+        action="store_true",
+        help="Open the final answer in a browser using a markdown template.",
+    )
+    parser.add_argument(
+        "--mail",
+        dest="mail_recipients",
+        help="Send the final answer via email to comma-separated addresses.",
+    )
+    parser.add_argument(
+        "--subject",
+        help="Subject line for the email (used with --mail).",
+    )
+    parser.add_argument("query", nargs="*", help="The query string")
+    return parser.parse_args()
+
+
+def show_banner(args) -> None:
+    """Display the application banner."""
+    model_alias = args.model
+    model_id = MODELS[model_alias]["id"]
+    sum_alias = SUMMARIZATION_MODEL
+    sum_id = MODELS[sum_alias]["id"]
+
+    model_ctx = MODELS[model_alias].get("context_size", DEFAULT_CONTEXT_SIZE)
+    sum_ctx = MODELS[sum_alias].get("context_size", DEFAULT_CONTEXT_SIZE)
+    db_count = get_db_record_count()
+
+    banner = get_banner(
+        model_alias,
+        model_id,
+        sum_alias,
+        sum_id,
+        DEFAULT_MODEL,
+        SEARCH_PROVIDER,
+        model_ctx,
+        sum_ctx,
+        MAX_TURNS,
+        db_count,
+    )
+    Console().print(banner)
+
+
+def handle_print_answer_implicit(args) -> bool:
+    """Handle implicit print answer (query is list of ints)."""
+    if not args.query:
+        return False
+    query_str = " ".join(args.query).strip()
+    if re.match(r"^(\d+\s*,?\s*)+$", query_str):
+        possible_ids = re.split(r"[,\s]+", query_str)
+        clean_ids_str = ",".join([x for x in possible_ids if x])
+        history.print_answers_command(
+            clean_ids_str,
+            args.summarize,
+            open_browser=args.open,
+            mail_recipients=args.mail_recipients,
+            subject=args.subject,
+        )
+        return True
+    return False
+
+
+def main() -> None:
+    """Main entry point."""
+    setup_logging(LOG_LEVEL, LOG_FILE)
+    args = parse_args()
+    init_db()
+
+    # Commands that don't require banner or query
+    if args.history is not None:
+        history.show_history_command(args.history)
+        return
+    if history.handle_cleanup_command(args):
+        return
+    if args.print_ids:
+        history.print_answers_command(
+            args.print_ids,
+            args.summarize,
+            open_browser=args.open,
+            mail_recipients=args.mail_recipients,
+            subject=args.subject,
+        )
+        return
+    if handle_print_answer_implicit(args):
+        return
+    if args.prompts:
+        prompts.list_prompts_command()
+        return
+
+    # From here on, we need a query
+    if not args.query:
+        print("Error: Query argument is required.")
+        return
+
+    # Expand query
+    query_text = utils.expand_query_text(" ".join(args.query), verbose=args.verbose)
+
+    # Verbose config
+    if args.verbose:
+        utils.print_config(
+            args,
+            MODELS,
+            DEFAULT_MODEL,
+            MAX_TURNS,
+            QUERY_SUMMARY_MAX_CHARS,
+            ANSWER_SUMMARY_MAX_CHARS,
+        )
+
+    # Show banner
+    show_banner(args)
+
+    # Run Chat
+    chat.run_chat(args, query_text)
+
+
+if __name__ == "__main__":
+    main()

asky/cli/prompts.py

@@ -0,0 +1,20 @@
+"""Prompt-related CLI commands for asky."""
+
+from asky.config import USER_PROMPTS
+
+
+def list_prompts_command() -> None:
+    """List all configured user prompts."""
+    if not USER_PROMPTS:
+        print("\nNo user prompts configured.")
+        return
+
+    print("\nConfigured User Prompts:")
+    print("-" * 40)
+    for alias, prompt in USER_PROMPTS.items():
+        print(
+            f"[{alias}]: {prompt[:100]}..."
+            if len(prompt) > 100
+            else f"[{alias}]: {prompt}"
+        )
+    print("-" * 40)