arka-agent 0.1.0__py3-none-any.whl

arka/__init__.py

@@ -0,0 +1,3 @@
+"""Arka — cross-platform AI agent."""
+
+__version__ = "0.1.0"

arka/__main__.py

@@ -0,0 +1,6 @@
+"""Allow: python -m arka"""
+
+from arka.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

arka/_bootstrap.py

@@ -0,0 +1,183 @@
+"""Bootstrap legacy flat imports and dev checkout paths."""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import sys
+from pathlib import Path
+from types import ModuleType
+
+_SRC = Path(__file__).resolve().parent.parent
+_ROOT = _SRC.parent.parent
+
+LEGACY_MODULES: dict[str, str] = {
+    "arka_paths": "arka.paths",
+    "arka_platform": "arka.core.platform",
+    "arka_progress": "arka.core.progress",
+    "arka_compute": "arka.core.compute",
+    "arka_disk": "arka.core.disk",
+    "arka_jsonkit": "arka.core.jsonkit",
+    "arka_timekit": "arka.core.timekit",
+    "arka_urlkit": "arka.core.urlkit",
+    "arka_textkit": "arka.core.textkit",
+    "arka_security": "arka.core.security",
+    "arka_usage": "arka.core.usage",
+    "arka_memory_detect": "arka.core.memory_detect",
+    "arka_session_memory": "arka.core.session_memory",
+    "arka_unified_memory": "arka.core.unified_memory",
+    "arka_memory": "arka.integrations.memory_cli",
+    "arka_personalize": "arka.core.personalize",
+    "arka_config": "arka.core.config_backup",
+    "arka_llm": "arka.llm.cli",
+    "arka_llm_fallback": "arka.llm.fallback",
+    "arka_llm_servers": "arka.llm.servers",
+    "arka_youtube": "arka.youtube.transcript",
+    "arka_youtube_research": "arka.youtube.research",
+    "arka_youtube_bulk": "arka.youtube.bulk",
+    "arka_ytdlp_progress": "arka.youtube.ytdlp_progress",
+    "arka_batch_summarize": "arka.media.batch",
+    "arka_media": "arka.media.transcript",
+    "arka_media_qa": "arka.media.qa",
+    "arka_summarize": "arka.media.summarize",
+    "arka_stock_bridge": "arka.stock.bridge",
+    "arka_stock_fundamentals": "arka.stock.fundamentals",
+    "arka_stock_ui": "arka.stock.ui",
+    "arka_stock_context_worker": "arka.stock.context_worker",
+    "arka_macro_events": "arka.stock.macro_events",
+    "arka_market_emotion": "arka.stock.emotion",
+    "arka_competition_funding": "arka.stock.competition_funding",
+    "arka_predictions": "arka.stock.predictions",
+    "arka_turboquant_install": "arka.stock.turboquant_install",
+    "arka_turboquant_rag": "arka.stock.turboquant_rag",
+    "arka_agent": "arka.agent.core",
+    "arka_professions": "arka.agent.professions",
+    "arka_profession_plugins": "arka.agent.profession_plugins",
+    "arka_profession_projects": "arka.agent.profession_projects",
+    "arka_chat": "arka.agent.chat",
+    "arka_survival_lang": "arka.agent.survival_lang",
+    "arka_pr_check": "arka.agent.pr_check",
+    "arka_github_repo": "arka.agent.github_repo",
+    "arka_competitions": "arka.agent.competitions",
+    "arka_bookmarks": "arka.agent.bookmarks",
+    "arka_repo_health": "arka.agent.repo_health",
+    "arka_free_credits": "arka.agent.free_credits",
+    "arka_repo_map": "arka.agent.repo_map",
+    "arka_repo_context": "arka.agent.repo_context",
+    "arka_self_improve": "arka.agent.self_improve",
+    "arka_generate_data": "arka.agent.generate_data",
+    "arka_data_ask": "arka.agent.data_ask",
+    "arka_view_data": "arka.agent.view_data",
+    "arka_docker_status": "arka.integrations.docker_status",
+    "arka_clipboard_history": "arka.integrations.clipboard_history",
+    "arka_route_learn": "arka.agent.route_learn",
+    "arka_skills": "arka.agent.skills",
+    "arka_talents": "arka.agent.talents",
+    "arka_wake": "arka.agent.wake",
+    "arka_voice": "arka.agent.voice",
+    "arka_stt_map": "arka.agent.stt_map",
+    "arka_assemblyai_stt": "arka.agent.assemblyai_stt",
+    "arka_supermemory": "arka.integrations.supermemory",
+    "arka_spotify": "arka.integrations.spotify",
+    "arka_whatsapp_inbox": "arka.integrations.whatsapp_inbox",
+    "arka_hf_bridge": "arka.integrations.hf_bridge",
+    "arka_remote_server": "arka.integrations.remote_server",
+    "arka_phone": "arka.integrations.phone",
+    "arka_remind": "arka.integrations.remind",
+    "arka_routines": "arka.integrations.routines",
+    "arka_heartbeat": "arka.integrations.heartbeat",
+    "arka_message_sessions": "arka.integrations.message_sessions",
+    "arka_subagent": "arka.integrations.subagent",
+    "arka_teams": "arka.integrations.teams_cli",
+    "arka_webhook": "arka.integrations.webhook",
+    "arka_sports": "arka.integrations.sports",
+    "arka_currency": "arka.integrations.currency",
+    "arka_open_url": "arka.integrations.open_url",
+    "arka_kalshi": "arka.integrations.kalshi",
+    "arka_kaggle": "arka.integrations.kaggle",
+    "arka_password_vault": "arka.integrations.password_vault",
+    "arka_google": "arka.integrations.google_workspace",
+    "arka_gemini": "arka.integrations.gemini_cli",
+    "arka_harvard_ark": "arka.integrations.harvard_ark",
+    "arka_fugu": "arka.integrations.fugu",
+    "arka_benchmark": "arka.integrations.benchmark_cli",
+    "arka_qr": "arka.integrations.qr_code",
+    "arka_mac_mic": "arka.integrations.mac_mic",
+    "arka_pdf_rag": "arka.pdf.rag",
+    "arka_pdf_tools": "arka.pdf.tools",
+    "arka_generate_image": "arka.generate.image",
+    "arka_generate_video": "arka.generate.video",
+    "arka_compose_slides": "arka.media.compose_slides",
+    "arka_compose_3d": "arka.media.compose_3d",
+    "arka_text_to_3d": "arka.agent.text_to_3d",
+    "arka_convert_media": "arka.media.convert_media",
+    "arka_chart": "arka.charts.plot",
+    "arka_ascii_art": "arka.agent.ascii_art",
+    "arka_flow": "arka.agent.flow",
+    "arka_fact_check": "arka.agent.fact_check",
+    "arka_astronomy": "arka.agent.astronomy",
+    "arka_metallurgy": "arka.agent.metallurgy",
+    "arka_three_d": "arka.media.compose_3d",
+    "arka_elon": "arka.agent.personas.elon",
+    "arka_persona": "arka.agent.personas.cli",
+    "arka_drawing": "arka.documents.drawing",
+    "arka_describe_image": "arka.vision.describe",
+    "arka_describe_video": "arka.vision.video",
+    "arka_aie": "arka.aie.cli",
+    "web_answer": "arka.agent.web_answer",
+    "edge_speak": "arka.voice.edge_speak",
+    "indic_tts": "arka.voice.indic_tts",
+    "sarvam_speak": "arka.voice.sarvam_speak",
+    "sarvam_stt": "arka.voice.sarvam_stt",
+    "spotify_dom": "arka.integrations.spotify_dom",
+}
+
+_bootstrapped = False
+
+
+def _ensure_src_on_path() -> None:
+    src_root = str(_ROOT / "src")
+    if src_root not in sys.path:
+        sys.path.insert(0, src_root)
+
+
+def install_legacy_aliases() -> None:
+    for legacy, qualname in LEGACY_MODULES.items():
+        if legacy in sys.modules:
+            continue
+        try:
+            sys.modules[legacy] = importlib.import_module(qualname)
+        except ImportError:
+            continue
+
+
+def bootstrap() -> None:
+    global _bootstrapped
+    if _bootstrapped:
+        return
+    _ensure_src_on_path()
+    _bootstrapped = True
+
+
+def run_legacy_module(qualname: str) -> int:
+    """Run a package module's ``main()`` or ``__main__`` block."""
+    bootstrap()
+    mod = importlib.import_module(qualname)
+    main = getattr(mod, "main", None)
+    if callable(main):
+        try:
+            params = list(inspect.signature(main).parameters)
+        except (TypeError, ValueError):
+            params = []
+        if params and params[0] in ("argv", "args"):
+            return int(main(sys.argv[1:]) or 0)
+        return int(main() or 0)
+    import runpy
+
+    runpy.run_module(qualname, run_name="__main__", alter_sys=True)
+    return 0
+
+
+def legacy_shim(qualname: str) -> ModuleType:
+    bootstrap()
+    return importlib.import_module(qualname)

arka/agent/__init__.py

@@ -0,0 +1 @@
+"""Arka agent."""

arka/agent/app_check.py

@@ -0,0 +1,52 @@
+"""Detect and validate common app build/test commands."""
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+from pathlib import Path
+
+
+def commands(root: Path) -> list[list[str]]:
+    if (root / "package.json").is_file():
+        return [["npm", "run", "build"], ["npm", "test", "--", "--runInBand"]]
+    if (root / "pyproject.toml").is_file() or (root / "setup.py").is_file():
+        return [["python", "-m", "compileall", "-q", "."], ["python", "-m", "pytest", "-q"]]
+    if (root / "Cargo.toml").is_file():
+        return [["cargo", "check"], ["cargo", "test"]]
+    if (root / "go.mod").is_file():
+        return [["go", "build", "./..."], ["go", "test", "./..."]]
+    return []
+
+
+def check(root: str = ".", *, run: bool = False) -> dict:
+    path = Path(root).expanduser().resolve()
+    plan = commands(path)
+    results = []
+    if run:
+        for command in plan:
+            proc = subprocess.run(command, cwd=path, text=True, capture_output=True, timeout=900, check=False)
+            results.append({"command": command, "exit_code": proc.returncode, "output": (proc.stdout + proc.stderr)[-4000:]})
+            if proc.returncode:
+                break
+    return {"root": str(path), "commands": plan, "results": results, "ok": not results or all(item["exit_code"] == 0 for item in results)}
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="arka app-check")
+    parser.add_argument("path", nargs="?", default=".")
+    parser.add_argument("--run", action="store_true", help="Run the detected build and test checks")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    payload = check(args.path, run=args.run)
+    if args.json:
+        print(json.dumps(payload, indent=2))
+    else:
+        print(f"Detected checks for {payload['root']}:")
+        for command in payload["commands"]:
+            print("  "+" ".join(command))
+        for result in payload["results"]:
+            print(f"  {'PASS' if result['exit_code'] == 0 else 'FAIL'} {' '.join(result['command'])}")
+            if result["exit_code"]:
+                print(result["output"])
+    return 0 if payload["ok"] else 1

arka/agent/ascii_art.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+"""Render text or images as ASCII art in the terminal."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+DEFAULT_FONT = "standard"
+ASCII_CHARS = "@%#*+=-:. "
+_IMAGE_EXT = r"(?:jpg|jpeg|png|gif|webp|bmp|tiff|tif)"
+
+# Minimal 5-row block font (A–Z, 0–9, space) when figlet/pyfiglet unavailable.
+_BLOCK_FONT: dict[str, list[str]] = {
+    " ": ["     ", "     ", "     ", "     ", "     "],
+    "0": [" ### ", "#   #", "#  ##", "# # #", " ### "],
+    "1": ["  #  ", " ##  ", "  #  ", "  #  ", " ### "],
+    "2": [" ### ", "#   #", "   # ", "  #  ", "#####"],
+    "3": [" ### ", "    #", " ### ", "    #", " ### "],
+    "4": [" #  #", "#  # ", "#####", "   # ", "   # "],
+    "5": ["#####", "#    ", "#### ", "    #", "#### "],
+    "6": [" ### ", "#    ", "#### ", "#   #", " ### "],
+    "7": ["#####", "   # ", "  #  ", " #   ", " #   "],
+    "8": [" ### ", "#   #", " ### ", "#   #", " ### "],
+    "9": [" ### ", "#   #", " ####", "    #", " ### "],
+    "A": [" ### ", "#   #", "#####", "#   #", "#   #"],
+    "B": ["#### ", "#   #", "#### ", "#   #", "#### "],
+    "C": [" ### ", "#   #", "#    ", "#   #", " ### "],
+    "D": ["#### ", "#   #", "#   #", "#   #", "#### "],
+    "E": ["#####", "#    ", "#### ", "#    ", "#####"],
+    "F": ["#####", "#    ", "#### ", "#    ", "#    "],
+    "G": [" ### ", "#    ", "#  ##", "#   #", " ### "],
+    "H": ["#   #", "#   #", "#####", "#   #", "#   #"],
+    "I": [" ### ", "  #  ", "  #  ", "  #  ", " ### "],
+    "J": ["  ###", "   # ", "   # ", "#  # ", " ##  "],
+    "K": ["#   #", "#  # ", "###  ", "#  # ", "#   #"],
+    "L": ["#    ", "#    ", "#    ", "#    ", "#####"],
+    "M": ["#   #", "## ##", "# # #", "#   #", "#   #"],
+    "N": ["#   #", "##  #", "# # #", "#  ##", "#   #"],
+    "O": [" ### ", "#   #", "#   #", "#   #", " ### "],
+    "P": ["#### ", "#   #", "#### ", "#    ", "#    "],
+    "Q": [" ### ", "#   #", "#   #", "#  ##", " ### "],
+    "R": ["#### ", "#   #", "#### ", "#  # ", "#   #"],
+    "S": [" ####", "#    ", " ### ", "    #", "#### "],
+    "T": ["#####", "  #  ", "  #  ", "  #  ", "  #  "],
+    "U": ["#   #", "#   #", "#   #", "#   #", " ### "],
+    "V": ["#   #", "#   #", "#   #", " # # ", "  #  "],
+    "W": ["#   #", "#   #", "# # #", "## ##", "#   #"],
+    "X": ["#   #", " # # ", "  #  ", " # # ", "#   #"],
+    "Y": ["#   #", " # # ", "  #  ", "  #  ", "  #  "],
+    "Z": ["#####", "   # ", "  #  ", " #   ", "#####"],
+}
+
+
+def _is_ascii_art_request(text: str) -> bool:
+    t = text.strip()
+    if not t:
+        return False
+    if re.search(rf"(?i)\b(?:from|of)\s+.+\.{_IMAGE_EXT}\b", t):
+        return True
+    if re.search(rf"(?i)\b.+\.{_IMAGE_EXT}\s+(?:to|into)\s+ascii", t):
+        return True
+    return bool(
+        re.search(
+            r"(?i)(?:^|\b)(?:make|create|show|print|render|draw)\s+(?:an?\s+)?ascii\s+(?:art|banner|text)\b",
+            t,
+        )
+        or re.search(r"(?i)(?:^|\b)ascii\s+(?:art|banner)\b", t)
+        or re.search(r"(?i)(?:^|\b)figlet\b", t)
+        or re.match(r"(?i)^ascii\s+\S", t)
+    )
+
+
+def _extract_text_prompt(text: str) -> str:
+    t = text.strip()
+    for pat in (
+        r"(?i)^(?:make|create|show|print|render|draw)\s+(?:an?\s+)?ascii\s+(?:art|banner|text)\s+(?:of|for|with|say(?:ing)?|that\s+says)?\s*",
+        r"(?i)^ascii\s+(?:art|banner)\s+(?:of|for|with|say(?:ing)?|that\s+says)?\s*",
+        r"(?i)^figlet\s+",
+        r"(?i)^ascii\s+",
+    ):
+        t = re.sub(pat, "", t).strip()
+    return t.strip("'\"")
+
+
+def _extract_image_path(text: str) -> str:
+    t = text.strip()
+    m = re.search(rf"(?i)(?:from|of)\s+([^\s'\"]+\.{_IMAGE_EXT})\b", t)
+    if m:
+        return m.group(1)
+    m = re.search(rf"(?i)([^\s'\"]+\.{_IMAGE_EXT})\s+(?:to|into)\s+ascii", t)
+    if m:
+        return m.group(1)
+    return ""
+
+
+def nl_to_argv(text: str) -> list[str]:
+    t = text.strip()
+    if not t or not _is_ascii_art_request(t):
+        return []
+
+    img = _extract_image_path(t)
+    if img:
+        argv = ["--from-image", img]
+        m = re.search(r"(?i)--width\s+(\d+)", t)
+        if m:
+            argv.extend(["--width", m.group(1)])
+        return argv
+
+    prompt = _extract_text_prompt(t)
+    m = re.search(r"(?i)(?:font|style)\s+([a-z0-9_-]+)", t)
+    if m:
+        prompt = re.sub(r"(?i)\s*(?:font|style)\s+[a-z0-9_-]+\s*$", "", prompt).strip()
+    if not prompt:
+        return []
+
+    argv = [prompt]
+    if m:
+        argv[:0] = ["--font", m.group(1)]
+    return argv
+
+
+def _render_pyfiglet(text: str, font: str) -> str | None:
+    try:
+        import pyfiglet
+    except ImportError:
+        return None
+    try:
+        return pyfiglet.figlet_format(text, font=font)
+    except Exception:
+        try:
+            return pyfiglet.figlet_format(text, font=DEFAULT_FONT)
+        except Exception:
+            return None
+
+
+def _render_system_figlet(text: str, font: str) -> str | None:
+    exe = shutil.which("figlet")
+    if not exe:
+        return None
+    for f in (font, DEFAULT_FONT):
+        try:
+            proc = subprocess.run(
+                [exe, "-f", f, text],
+                capture_output=True,
+                text=True,
+                timeout=15,
+                check=False,
+            )
+            if proc.returncode == 0 and proc.stdout.strip():
+                return proc.stdout
+        except (OSError, subprocess.TimeoutExpired):
+            continue
+    return None
+
+
+def _render_npx_figlet(text: str) -> str | None:
+    if not shutil.which("npx"):
+        return None
+    try:
+        proc = subprocess.run(
+            ["npx", "--yes", "figlet-cli", text],
+            capture_output=True,
+            text=True,
+            timeout=45,
+            check=False,
+        )
+        if proc.returncode == 0 and proc.stdout.strip():
+            return proc.stdout
+    except (OSError, subprocess.TimeoutExpired):
+        pass
+    return None
+
+
+def _render_block_fallback(text: str) -> str:
+    rows = [""] * 5
+    for ch in text.upper():
+        glyph = _BLOCK_FONT.get(ch, _BLOCK_FONT.get("?"))
+        if glyph is None:
+            glyph = ["  ?  ", " # # ", "  #  ", " # # ", "  ?  "]
+        for i, line in enumerate(glyph):
+            rows[i] += line + " "
+    return "\n".join(rows).rstrip() + "\n"
+
+
+def render_text(text: str, font: str = DEFAULT_FONT) -> str:
+    text = text.strip()
+    if not text:
+        raise ValueError("empty text")
+    for fn in (
+        lambda: _render_pyfiglet(text, font),
+        lambda: _render_system_figlet(text, font),
+        lambda: _render_npx_figlet(text),
+    ):
+        out = fn()
+        if out:
+            return out if out.endswith("\n") else out + "\n"
+    return _render_block_fallback(text)
+
+
+def image_to_ascii(path: Path, width: int = 80) -> str:
+    try:
+        from PIL import Image
+    except ImportError as exc:
+        raise SystemExit(
+            "Pillow is required for image-to-ASCII.\n"
+            "Install: pip install Pillow\n"
+            "Or: pip install 'arka-agent[vision]'"
+        ) from exc
+
+    if not path.is_file():
+        raise SystemExit(f"Image not found: {path}")
+
+    width = max(20, min(width, 200))
+    img = Image.open(path).convert("L")
+    aspect = img.height / img.width if img.width else 1
+    height = max(1, int(width * aspect * 0.55))
+    img = img.resize((width, height))
+
+    lines: list[str] = []
+    pixels = img.load()
+    for y in range(height):
+        row = []
+        for x in range(width):
+            lum = pixels[x, y] if pixels is not None else 0
+            idx = int(lum / 256 * len(ASCII_CHARS))
+            idx = min(idx, len(ASCII_CHARS) - 1)
+            row.append(ASCII_CHARS[idx])
+        lines.append("".join(row))
+    return "\n".join(lines) + "\n"
+
+
+def render_and_output(
+    *,
+    text: str = "",
+    font: str = DEFAULT_FONT,
+    from_image: str = "",
+    width: int = 80,
+    output: str = "",
+) -> int:
+    if from_image:
+        art = image_to_ascii(Path(from_image).expanduser(), width=width)
+    else:
+        if not text.strip():
+            print("Usage: ascii_art <text> [--font NAME] [-o path]", file=sys.stderr)
+            print("       ascii_art --from-image photo.jpg [--width 80]", file=sys.stderr)
+            return 1
+        art = render_text(text, font=font)
+
+    print(art, end="" if art.endswith("\n") else "\n")
+
+    if output:
+        out = Path(output).expanduser()
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(art, encoding="utf-8")
+        print(f"Saved: {out}")
+
+    return 0
+
+
+def cmd_parse(args: argparse.Namespace) -> int:
+    argv = nl_to_argv(" ".join(args.text))
+    if not argv:
+        return 1
+    print(" ".join(shlex.quote(a) for a in argv))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="Render ASCII art (figlet / pyfiglet / image)")
+    sub = p.add_subparsers(dest="cmd")
+
+    p_parse = sub.add_parser("parse", help="Parse natural language → ascii_art args")
+    p_parse.add_argument("text", nargs="+")
+    p_parse.set_defaults(func=cmd_parse)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(argv if argv is not None else sys.argv[1:])
+    if argv and argv[0] == "parse":
+        args = build_parser().parse_args(argv)
+        return args.func(args)
+
+    if argv and argv[0] in {"-h", "--help", "help"}:
+        build_parser().print_help()
+        return 0
+
+    nl = nl_to_argv(" ".join(argv))
+    if nl and not any(a.startswith("-") for a in argv[:2]):
+        argv = nl
+
+    parser = argparse.ArgumentParser(description="Render ASCII art (figlet / pyfiglet / image)")
+    parser.add_argument("text", nargs="*", help="Text to render")
+    parser.add_argument("-f", "--font", default=DEFAULT_FONT, help="Figlet font name")
+    parser.add_argument("--from-image", metavar="PATH", help="Convert image to ASCII")
+    parser.add_argument("--width", type=int, default=80, help="Image ASCII width (default 80)")
+    parser.add_argument("-o", "--output", help="Save output to file (also prints to terminal)")
+    args = parser.parse_args(argv)
+
+    if args.from_image:
+        return render_and_output(from_image=args.from_image, width=args.width, output=args.output or "")
+
+    text = " ".join(args.text).strip()
+    return render_and_output(text=text, font=args.font, output=args.output or "")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())