gpt-command 0.1.0__tar.gz

gpt_command-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: gpt-command
+Version: 0.1.0
+Summary: Ask GPT for Ubuntu/macOS/Linux shell commands from natural language
+Author: Your Name
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=2.0.0
+Requires-Dist: tqdm>=4.66.0
+
+# gpt-command (gptc)
+
+> Turn natural language into ready-to-use terminal commands.
+
+`gptc` is a lightweight CLI tool that converts plain English (or any language) into executable shell commands for macOS and Linux.
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install gpt-command
+```
+
+---
+
+🔑 Setup API Key
+
+Run once to store your OpenAI API key securely:
+
+```bash
+gptc-key
+```
+Check status:
+
+```bash
+gptc-key --status
+```
+Set default model (optional):
+
+```bash
+gptc-key --model gpt-4.1
+```
+
+---
+
+💡 Usage
+```bash
+gptc <your question>
+```
+Example
+```bash
+gptc find and delete all txt files in current directory recursively
+```
+Output:
+```bash
+find . -type f -name "*.txt" -delete
+```
+Then it will automatically prefill your terminal input:
+
+```bash
+~/current/path$ find . -type f -name "*.txt" -delete
+```
+⚠️ The command is NOT executed automatically.
+
+---
+
+⚙️ Options
+
+📋 Copy to clipboard
+
+```bash
+gptc --copy compress current folder into tar.gz
+```
+📖 Show explanation
+
+```bash
+gptc --explain find process using port 8000
+```
+▶️ Execute command (with confirmation)
+
+```bash
+gptc --run check disk usage
+```
+🧠 Show history
+
+```bash
+gptc --history
+```
+🤖 Specify model
+
+```bash
+gptc --model gpt-4.1 list all running processes
+```
+
+---
+
+🔐 Security
+
+- API key is stored locally at:
+
+```bash
+~/.config/gptc/config.json
+```
+File permissions are restricted to the user (600)
+Dangerous commands are automatically detected and blocked from execution
+
+---
+
+⚠️ Disclaimer
+- Always review generated commands before running them
+- Some commands may modify or delete system data
+- Use with caution, especially with elevated privileges (sudo)
+
+---
+
+🖥️ Supported Platforms
+
+- macOS
+- Linux (Ubuntu, etc.)
+
+---
+
+✨ Features
+- Natural language → shell command
+- Auto-prefilled terminal input (no copy-paste needed)
+- Optional execution with confirmation
+- Clipboard copy support
+- Command explanation
+- History tracking
+- Local API key management (no environment variable required)
+
+---
+
+📌 Summary
+
+> Stop Googling terminal commands. Just ask.
+
+---
+
+📄 License
+
+MIT License

gpt_command-0.1.0/README.md

@@ -0,0 +1,133 @@
+# gpt-command (gptc)
+
+> Turn natural language into ready-to-use terminal commands.
+
+`gptc` is a lightweight CLI tool that converts plain English (or any language) into executable shell commands for macOS and Linux.
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install gpt-command
+```
+
+---
+
+🔑 Setup API Key
+
+Run once to store your OpenAI API key securely:
+
+```bash
+gptc-key
+```
+Check status:
+
+```bash
+gptc-key --status
+```
+Set default model (optional):
+
+```bash
+gptc-key --model gpt-4.1
+```
+
+---
+
+💡 Usage
+```bash
+gptc <your question>
+```
+Example
+```bash
+gptc find and delete all txt files in current directory recursively
+```
+Output:
+```bash
+find . -type f -name "*.txt" -delete
+```
+Then it will automatically prefill your terminal input:
+
+```bash
+~/current/path$ find . -type f -name "*.txt" -delete
+```
+⚠️ The command is NOT executed automatically.
+
+---
+
+⚙️ Options
+
+📋 Copy to clipboard
+
+```bash
+gptc --copy compress current folder into tar.gz
+```
+📖 Show explanation
+
+```bash
+gptc --explain find process using port 8000
+```
+▶️ Execute command (with confirmation)
+
+```bash
+gptc --run check disk usage
+```
+🧠 Show history
+
+```bash
+gptc --history
+```
+🤖 Specify model
+
+```bash
+gptc --model gpt-4.1 list all running processes
+```
+
+---
+
+🔐 Security
+
+- API key is stored locally at:
+
+```bash
+~/.config/gptc/config.json
+```
+File permissions are restricted to the user (600)
+Dangerous commands are automatically detected and blocked from execution
+
+---
+
+⚠️ Disclaimer
+- Always review generated commands before running them
+- Some commands may modify or delete system data
+- Use with caution, especially with elevated privileges (sudo)
+
+---
+
+🖥️ Supported Platforms
+
+- macOS
+- Linux (Ubuntu, etc.)
+
+---
+
+✨ Features
+- Natural language → shell command
+- Auto-prefilled terminal input (no copy-paste needed)
+- Optional execution with confirmation
+- Clipboard copy support
+- Command explanation
+- History tracking
+- Local API key management (no environment variable required)
+
+---
+
+📌 Summary
+
+> Stop Googling terminal commands. Just ask.
+
+---
+
+📄 License
+
+MIT License

gpt_command-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gpt-command"
+version = "0.1.0"
+description = "Ask GPT for Ubuntu/macOS/Linux shell commands from natural language"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+  { name = "Your Name" }
+]
+dependencies = [
+  "openai>=2.0.0",
+  "tqdm>=4.66.0"
+]
+
+[project.scripts]
+gptc = "gpt_command.cli:main"
+gptc-key = "gpt_command.key_manager:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

gpt_command-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gpt_command-0.1.0/src/gpt_command/__init__.py

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

gpt_command-0.1.0/src/gpt_command/cli.py

@@ -0,0 +1,226 @@
+import argparse
+import sys
+
+from openai import OpenAI
+from tqdm import tqdm
+
+from .config import get_api_key, get_default_model
+from .history import print_history, save_history_item
+from .utils import (
+    copy_to_clipboard,
+    extract_command,
+    is_dangerous_command,
+    prefilled_input,
+    run_shell_command,
+    yes_no,
+)
+
+SYSTEM_PROMPT = """You are a Linux/macOS terminal command generator.
+
+Follow these rules exactly:
+1. Output only one executable shell command on a single line.
+2. Do not output explanations, code fences, quotes, or extra text.
+3. Prefer commands that work in bash/zsh environments.
+4. If the user's request is risky or destructive, suggest the safest practical command possible.
+5. If multiple steps are needed, combine them into a single one-liner using && when appropriate.
+6. Return only the command string.
+"""
+
+EXPLAIN_PROMPT = """You are a Linux/macOS terminal command explainer.
+Explain the given command in up to 3 short lines:
+1. What it does
+2. What the important options mean
+3. Any caution the user should know
+"""
+
+
+def ask_model_for_command(question: str, model: str) -> str:
+    api_key = get_api_key()
+    if not api_key:
+        raise RuntimeError(
+            "No OpenAI API key found. Run `gptc-key` first to store your API key."
+        )
+
+    client = OpenAI(api_key=api_key)
+
+    with tqdm(total=3, desc="GPT processing", ncols=88) as pbar:
+        pbar.set_description("Preparing request")
+        pbar.update(1)
+
+        response = client.responses.create(
+            model=model,
+            instructions=SYSTEM_PROMPT,
+            input=f"Convert this natural language request into a single shell command:\n{question}",
+        )
+
+        pbar.set_description("Receiving response")
+        pbar.update(1)
+
+        text = getattr(response, "output_text", "") or ""
+        command = extract_command(text)
+
+        pbar.set_description("Finalizing result")
+        pbar.update(1)
+
+    if not command:
+        raise RuntimeError("Failed to extract a command from the model response.")
+
+    return command
+
+
+def ask_model_for_explanation(command: str, model: str) -> str:
+    api_key = get_api_key()
+    if not api_key:
+        raise RuntimeError(
+            "No OpenAI API key found. Run `gptc-key` first to store your API key."
+        )
+
+    client = OpenAI(api_key=api_key)
+
+    with tqdm(total=2, desc="Generating explanation", ncols=88) as pbar:
+        pbar.set_description("Sending request")
+        pbar.update(1)
+
+        response = client.responses.create(
+            model=model,
+            instructions=EXPLAIN_PROMPT,
+            input=command,
+        )
+
+        pbar.set_description("Receiving explanation")
+        pbar.update(1)
+
+    text = getattr(response, "output_text", "") or ""
+    return text.strip()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="gptc",
+        description="Convert natural language into terminal commands for macOS and Linux.",
+    )
+    parser.add_argument("question", nargs="*", help="Your natural language request.")
+    parser.add_argument("--copy", action="store_true", help="Copy the result to the clipboard.")
+    parser.add_argument("--explain", action="store_true", help="Show a short explanation of the command.")
+    parser.add_argument("--run", action="store_true", help="Run the generated command after confirmation.")
+    parser.add_argument("--model", type=str, default=None, help="Specify the model to use.")
+    parser.add_argument("--history", action="store_true", help="Show recent command history.")
+    return parser
+
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.history:
+        print_history(limit=10)
+        return
+
+    if not args.question:
+        parser.print_help()
+        sys.exit(1)
+
+    question = " ".join(args.question).strip()
+    model = args.model or get_default_model()
+
+    try:
+        command = ask_model_for_command(question, model=model)
+    except KeyboardInterrupt:
+        print("\nInterrupted.")
+        sys.exit(130)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print(command)
+
+    explained = False
+    if args.explain:
+        try:
+            explanation = ask_model_for_explanation(command, model=model)
+            if explanation:
+                print("\n[Explanation]")
+                print(explanation)
+                explained = True
+        except Exception as e:
+            print(f"\nExplanation failed: {e}")
+
+    copied = False
+    if args.copy:
+        copied = copy_to_clipboard(command)
+        if copied:
+            print("\nCopied to clipboard.")
+        else:
+            print("\nFailed to copy to clipboard. Check pbcopy, xclip, or wl-copy.")
+
+    if is_dangerous_command(command):
+        print(
+            "\n[Warning] A potentially dangerous command pattern was detected. "
+            "Auto-run and auto-prefill have been blocked."
+        )
+        save_history_item(
+            question=question,
+            command=command,
+            executed=False,
+            copied=copied,
+            explained=explained,
+        )
+        sys.exit(2)
+
+    if args.run:
+        print()
+        if yes_no("Do you want to run this command?", default="n"):
+            code = run_shell_command(command)
+            print(f"\nExit code: {code}")
+            save_history_item(
+                question=question,
+                command=command,
+                executed=True,
+                copied=copied,
+                explained=explained,
+            )
+            sys.exit(code)
+        else:
+            print("Execution cancelled.")
+            save_history_item(
+                question=question,
+                command=command,
+                executed=False,
+                copied=copied,
+                explained=explained,
+            )
+            sys.exit(0)
+
+    try:
+        print()
+        entered = prefilled_input(command)
+        if entered.strip():
+            print("Input prefilled successfully.")
+    except KeyboardInterrupt:
+        print("\nCancelled.")
+        save_history_item(
+            question=question,
+            command=command,
+            executed=False,
+            copied=copied,
+            explained=explained,
+        )
+        sys.exit(130)
+    except EOFError:
+        print()
+        save_history_item(
+            question=question,
+            command=command,
+            executed=False,
+            copied=copied,
+            explained=explained,
+        )
+        sys.exit(0)
+
+    save_history_item(
+        question=question,
+        command=command,
+        executed=False,
+        copied=copied,
+        explained=explained,
+    )

gpt_command-0.1.0/src/gpt_command/config.py

@@ -0,0 +1,76 @@
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+APP_NAME = "gptc"
+CONFIG_DIR = Path.home() / ".config" / APP_NAME
+CONFIG_FILE = CONFIG_DIR / "config.json"
+HISTORY_FILE = CONFIG_DIR / "history.json"
+
+
+def ensure_config_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_json_file(path: Path, default: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    if default is None:
+        default = {}
+
+    if not path.exists():
+        return default
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return default
+
+
+def save_json_file(path: Path, data: Dict[str, Any]) -> None:
+    ensure_config_dir()
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    os.chmod(path, 0o600)
+
+
+def load_config() -> Dict[str, Any]:
+    return load_json_file(CONFIG_FILE, default={})
+
+
+def save_config(data: Dict[str, Any]) -> None:
+    save_json_file(CONFIG_FILE, data)
+
+
+def get_api_key() -> Optional[str]:
+    # 1순위: 환경변수
+    env_key = os.environ.get("OPENAI_API_KEY")
+    if env_key:
+        return env_key.strip()
+
+    # 2순위: 로컬 설정 파일
+    config = load_config()
+    key = config.get("OPENAI_API_KEY")
+    if isinstance(key, str) and key.strip():
+        return key.strip()
+
+    return None
+
+
+def get_default_model() -> str:
+    env_model = os.environ.get("OPENAI_MODEL")
+    if env_model and env_model.strip():
+        return env_model.strip()
+
+    config = load_config()
+    model = config.get("DEFAULT_MODEL")
+    if isinstance(model, str) and model.strip():
+        return model.strip()
+
+    return "gpt-4.1"
+
+
+def set_default_model(model: str) -> None:
+    config = load_config()
+    config["DEFAULT_MODEL"] = model
+    save_config(config)

gpt_command-0.1.0/src/gpt_command/history.py

@@ -0,0 +1,53 @@
+from datetime import datetime
+from typing import Any, Dict, List
+
+from .config import HISTORY_FILE, load_json_file, save_json_file
+
+MAX_HISTORY = 50
+
+
+def load_history() -> List[Dict[str, Any]]:
+    data = load_json_file(HISTORY_FILE, default={"items": []})
+    items = data.get("items", [])
+    if isinstance(items, list):
+        return items
+    return []
+
+
+def save_history_item(
+    question: str,
+    command: str,
+    executed: bool = False,
+    copied: bool = False,
+    explained: bool = False,
+) -> None:
+    items = load_history()
+    items.insert(
+        0,
+        {
+            "timestamp": datetime.now().isoformat(timespec="seconds"),
+            "question": question,
+            "command": command,
+            "executed": executed,
+            "copied": copied,
+            "explained": explained,
+        },
+    )
+    items = items[:MAX_HISTORY]
+    save_json_file(HISTORY_FILE, {"items": items})
+
+
+def print_history(limit: int = 10) -> None:
+    items = load_history()[:limit]
+    if not items:
+        print("히스토리가 없습니다.")
+        return
+
+    for i, item in enumerate(items, start=1):
+        ts = item.get("timestamp", "-")
+        q = item.get("question", "")
+        cmd = item.get("command", "")
+        print(f"[{i}] {ts}")
+        print(f"  질문: {q}")
+        print(f"  명령: {cmd}")
+        print()

gpt_command-0.1.0/src/gpt_command/key_manager.py

@@ -0,0 +1,80 @@
+import argparse
+import getpass
+
+from .config import CONFIG_FILE, get_api_key, load_config, save_config, set_default_model
+
+
+def set_api_key() -> None:
+    print("Enter your OpenAI API key. Input will be hidden.")
+    key = getpass.getpass("API Key: ").strip()
+
+    if not key:
+        print("No key was entered.")
+        return
+
+    config = load_config()
+    config["OPENAI_API_KEY"] = key
+    save_config(config)
+    print(f"API key saved: {CONFIG_FILE}")
+
+
+def delete_api_key() -> None:
+    config = load_config()
+    if "OPENAI_API_KEY" in config:
+        del config["OPENAI_API_KEY"]
+        save_config(config)
+        print("Stored API key deleted.")
+    else:
+        print("No stored API key found.")
+
+
+def show_status() -> None:
+    key = get_api_key()
+    if key:
+        masked = key[:7] + "*" * max(0, len(key) - 11) + key[-4:]
+        print("API key is configured.")
+        print(f"Key preview: {masked}")
+    else:
+        print("API key is not configured.")
+
+    config = load_config()
+    model = config.get("DEFAULT_MODEL", "gpt-4.1")
+    print(f"Default model: {model}")
+
+
+def set_model(model: str) -> None:
+    set_default_model(model)
+    print(f"Default model saved: {model}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="gptc-key",
+        description="Manage gptc API key and default model settings.",
+    )
+    parser.add_argument("--set", action="store_true", help="Set the API key.")
+    parser.add_argument("--delete", action="store_true", help="Delete the stored API key.")
+    parser.add_argument("--status", action="store_true", help="Show current configuration status.")
+    parser.add_argument("--model", type=str, help="Set the default model.")
+
+    args = parser.parse_args()
+    acted = False
+
+    if args.set:
+        set_api_key()
+        acted = True
+
+    if args.delete:
+        delete_api_key()
+        acted = True
+
+    if args.status:
+        show_status()
+        acted = True
+
+    if args.model:
+        set_model(args.model)
+        acted = True
+
+    if not acted:
+        set_api_key()

gpt_command-0.1.0/src/gpt_command/utils.py

@@ -0,0 +1,117 @@
+import os
+import platform
+import readline
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+
+DANGEROUS_PATTERNS = [
+    "rm -rf /",
+    "rm -rf ~",
+    "mkfs",
+    "dd if=",
+    ":(){ :|:& };:",
+    "shutdown -h now",
+    "reboot",
+    "poweroff",
+    "halt",
+    "chmod -R 777 /",
+    "chown -R",
+    "> /dev/sda",
+    "> /dev/nvme",
+]
+
+
+def is_dangerous_command(cmd: str) -> bool:
+    lowered = cmd.lower()
+    return any(p.lower() in lowered for p in DANGEROUS_PATTERNS)
+
+
+def build_prompt() -> str:
+    cwd = Path.cwd()
+    home = Path.home()
+
+    try:
+        cwd_str = str(cwd)
+        home_str = str(home)
+        if cwd_str.startswith(home_str):
+            cwd_display = cwd_str.replace(home_str, "~", 1)
+        else:
+            cwd_display = cwd_str
+    except Exception:
+        cwd_display = str(cwd)
+
+    return f"{cwd_display}$ "
+
+
+def prefilled_input(prefill: str, prompt: Optional[str] = None) -> str:
+    if prompt is None:
+        prompt = build_prompt()
+
+    def hook() -> None:
+        readline.insert_text(prefill)
+        readline.redisplay()
+
+    old_hook = readline.get_startup_hook()
+    try:
+        readline.set_startup_hook(hook)
+        return input(prompt)
+    finally:
+        readline.set_startup_hook(old_hook)
+
+
+def extract_command(text: str) -> str:
+    cmd = text.strip()
+
+    if cmd.startswith("```"):
+        lines = [line for line in cmd.splitlines() if not line.strip().startswith("```")]
+        cmd = "\n".join(lines).strip()
+
+    if "\n" in cmd:
+        cmd = cmd.splitlines()[0].strip()
+
+    cmd = cmd.strip().strip("`").strip()
+    cmd = cmd.strip('"').strip("'").strip()
+
+    return cmd
+
+
+def copy_to_clipboard(text: str) -> bool:
+    system = platform.system()
+
+    try:
+        if system == "Darwin" and shutil.which("pbcopy"):
+            subprocess.run(["pbcopy"], input=text, text=True, check=True)
+            return True
+
+        if shutil.which("wl-copy"):
+            subprocess.run(["wl-copy"], input=text, text=True, check=True)
+            return True
+
+        if shutil.which("xclip"):
+            subprocess.run(["xclip", "-selection", "clipboard"], input=text, text=True, check=True)
+            return True
+
+        return False
+    except Exception:
+        return False
+
+
+def run_shell_command(cmd: str) -> int:
+    try:
+        completed = subprocess.run(cmd, shell=True)
+        return completed.returncode
+    except KeyboardInterrupt:
+        return 130
+
+
+def yes_no(question: str, default: str = "n") -> bool:
+    default = default.lower().strip()
+    prompt = " [Y/n] " if default == "y" else " [y/N] "
+
+    answer = input(question + prompt).strip().lower()
+    if not answer:
+        return default == "y"
+    return answer in {"y", "yes"}

gpt_command-0.1.0/src/gpt_command.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: gpt-command
+Version: 0.1.0
+Summary: Ask GPT for Ubuntu/macOS/Linux shell commands from natural language
+Author: Your Name
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=2.0.0
+Requires-Dist: tqdm>=4.66.0
+
+# gpt-command (gptc)
+
+> Turn natural language into ready-to-use terminal commands.
+
+`gptc` is a lightweight CLI tool that converts plain English (or any language) into executable shell commands for macOS and Linux.
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install gpt-command
+```
+
+---
+
+🔑 Setup API Key
+
+Run once to store your OpenAI API key securely:
+
+```bash
+gptc-key
+```
+Check status:
+
+```bash
+gptc-key --status
+```
+Set default model (optional):
+
+```bash
+gptc-key --model gpt-4.1
+```
+
+---
+
+💡 Usage
+```bash
+gptc <your question>
+```
+Example
+```bash
+gptc find and delete all txt files in current directory recursively
+```
+Output:
+```bash
+find . -type f -name "*.txt" -delete
+```
+Then it will automatically prefill your terminal input:
+
+```bash
+~/current/path$ find . -type f -name "*.txt" -delete
+```
+⚠️ The command is NOT executed automatically.
+
+---
+
+⚙️ Options
+
+📋 Copy to clipboard
+
+```bash
+gptc --copy compress current folder into tar.gz
+```
+📖 Show explanation
+
+```bash
+gptc --explain find process using port 8000
+```
+▶️ Execute command (with confirmation)
+
+```bash
+gptc --run check disk usage
+```
+🧠 Show history
+
+```bash
+gptc --history
+```
+🤖 Specify model
+
+```bash
+gptc --model gpt-4.1 list all running processes
+```
+
+---
+
+🔐 Security
+
+- API key is stored locally at:
+
+```bash
+~/.config/gptc/config.json
+```
+File permissions are restricted to the user (600)
+Dangerous commands are automatically detected and blocked from execution
+
+---
+
+⚠️ Disclaimer
+- Always review generated commands before running them
+- Some commands may modify or delete system data
+- Use with caution, especially with elevated privileges (sudo)
+
+---
+
+🖥️ Supported Platforms
+
+- macOS
+- Linux (Ubuntu, etc.)
+
+---
+
+✨ Features
+- Natural language → shell command
+- Auto-prefilled terminal input (no copy-paste needed)
+- Optional execution with confirmation
+- Clipboard copy support
+- Command explanation
+- History tracking
+- Local API key management (no environment variable required)
+
+---
+
+📌 Summary
+
+> Stop Googling terminal commands. Just ask.
+
+---
+
+📄 License
+
+MIT License

gpt_command-0.1.0/src/gpt_command.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/gpt_command/__init__.py
+src/gpt_command/cli.py
+src/gpt_command/config.py
+src/gpt_command/history.py
+src/gpt_command/key_manager.py
+src/gpt_command/utils.py
+src/gpt_command.egg-info/PKG-INFO
+src/gpt_command.egg-info/SOURCES.txt
+src/gpt_command.egg-info/dependency_links.txt
+src/gpt_command.egg-info/entry_points.txt
+src/gpt_command.egg-info/requires.txt
+src/gpt_command.egg-info/top_level.txt

gpt_command-0.1.0/src/gpt_command.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gpt_command-0.1.0/src/gpt_command.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gptc = gpt_command.cli:main
+gptc-key = gpt_command.key_manager:main

gpt_command-0.1.0/src/gpt_command.egg-info/requires.txt

@@ -0,0 +1,2 @@
+openai>=2.0.0
+tqdm>=4.66.0

gpt_command-0.1.0/src/gpt_command.egg-info/top_level.txt

@@ -0,0 +1 @@
+gpt_command