notrack-cli-agent 0.0.0__py3-none-any.whl

notrack_cli/memory.py

@@ -0,0 +1,73 @@
+import os
+import json
+import time
+
+HISTORY_DIR = os.path.expanduser("~/.notrack_cli")
+SESSION_FILE = os.path.join(HISTORY_DIR, "session_history.json")
+CHECKPOINT_FILE = os.path.join(HISTORY_DIR, "checkpoint.json")
+
+class MemoryManager:
+    @staticmethod
+    def ensure_dir():
+        os.makedirs(HISTORY_DIR, exist_ok=True)
+
+    @staticmethod
+    def load_history():
+        MemoryManager.ensure_dir()
+        if os.path.exists(SESSION_FILE):
+            try:
+                with open(SESSION_FILE, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception:
+                return []
+        return []
+
+    @staticmethod
+    def save_history(messages):
+        MemoryManager.ensure_dir()
+        try:
+            with open(SESSION_FILE, "w", encoding="utf-8") as f:
+                json.dump(messages[-50:], f, ensure_ascii=False, indent=2)
+        except Exception:
+            pass
+
+    @staticmethod
+    def save_checkpoint(user_input, response_so_far, current_chat_id):
+        MemoryManager.ensure_dir()
+        data = {
+            "timestamp": time.time(),
+            "chat_id": current_chat_id,
+            "user_input": user_input,
+            "partial_response": response_so_far
+        }
+        try:
+            with open(CHECKPOINT_FILE, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except Exception:
+            pass
+
+    @staticmethod
+    def load_checkpoint():
+        if os.path.exists(CHECKPOINT_FILE):
+            try:
+                with open(CHECKPOINT_FILE, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception:
+                return None
+        return None
+
+    @staticmethod
+    def clear_checkpoint():
+        if os.path.exists(CHECKPOINT_FILE):
+            try:
+                os.remove(CHECKPOINT_FILE)
+            except Exception:
+                pass
+
+    @staticmethod
+    def clear_history():
+        if os.path.exists(SESSION_FILE):
+            try:
+                os.remove(SESSION_FILE)
+            except Exception:
+                pass

notrack_cli/parser.py

@@ -0,0 +1,36 @@
+"""Parse only explicit structured tool calls emitted by the model.
+
+Plain prose or a fenced source-code sample is never interpreted as permission
+for local execution.
+"""
+import json
+import re
+
+_TAG_RE = re.compile(
+    r'<tool_call:([a-zA-Z_]\w*)>\s*(.*?)\s*</tool_call:\1>',
+    re.DOTALL | re.IGNORECASE,
+)
+_FENCE_RE = re.compile(
+    r'```tool_call:([a-zA-Z_]\w*)\s*\n(.*?)\n```',
+    re.DOTALL | re.IGNORECASE,
+)
+
+
+def extract_tool_calls(text: str) -> list[tuple[str, dict, str]]:
+    """Return explicit (tool name, JSON arguments, raw tag) calls only."""
+    calls = []
+    for pattern in (_TAG_RE, _FENCE_RE):
+        for match in pattern.finditer(text):
+            try:
+                args = json.loads(match.group(2))
+            except (json.JSONDecodeError, TypeError):
+                continue
+            if isinstance(args, dict):
+                calls.append((match.group(1), args, match.group(0)))
+    # Prevent duplicate calls if content somehow matches both grammars.
+    seen, unique = set(), []
+    for call in calls:
+        if call[2] not in seen:
+            seen.add(call[2])
+            unique.append(call)
+    return unique

notrack_cli/tools.py

@@ -0,0 +1,233 @@
+import os
+import subprocess
+import shutil
+import urllib.request
+import json
+import platform
+
+# ──────────────────────────────────────────────────────────────
+#  SYSTEM PROMPT  (sent to NoTrack AI on first turn)
+# ──────────────────────────────────────────────────────────────
+SYSTEM_PROMPT = """You are NoTrack Agent — an elite autonomous AI engineer and pair-programmer technically and physically created by Chris(Chr15zKH4x), running directly inside the user's terminal (Termux, Linux, macOS).
+
+━━━ IDENTITY ━━━
+You are a senior software architect + DevOps engineer + security researcher in one.
+You produce COMPLETE, PRODUCTION-GRADE, WORKING code. Never write stubs or placeholders.
+You are direct and technically precise. No filler phrases. No apologies.
+When given a coding task: PLAN → ACT (use tools) → VERIFY (run tests/commands).
+
+━━━ CRITICAL RULE ━━━
+You have real tools that execute on the user's system RIGHT NOW.
+When the user asks you to "create a file", "write a script", "run a command":
+→ USE THE TOOL. Do NOT just show code in markdown. USE write_file or run_command.
+→ The CLI will execute your tool calls and show the results live.
+
+━━━ AVAILABLE TOOLS ━━━
+
+1. CREATE OR WRITE A FILE (creates parent dirs automatically):
+<tool_call:write_file>
+{"path": "relative/or/absolute/path.ext", "content": "complete file content here"}
+</tool_call:write_file>
+
+2. READ A FILE:
+<tool_call:view_file>
+{"path": "path/to/file"}
+</tool_call:view_file>
+
+3. RUN ANY SHELL COMMAND (git, pip, npm, python, bash, rm, mkdir, zip, unzip — all allowed):
+<tool_call:run_command>
+{"command": "git push origin main"}
+</tool_call:run_command>
+
+4. LIST DIRECTORY:
+<tool_call:list_dir>
+{"path": "."}
+</tool_call:list_dir>
+
+5. SPAWN A PARALLEL SUB-AGENT for complex sub-tasks:
+<tool_call:sub_agent>
+{"task": "Detailed autonomous sub-task description"}
+</tool_call:sub_agent>
+
+6. FETCH A WEB PAGE / DOCUMENTATION:
+<tool_call:fetch_url>
+{"url": "https://chr15zkh4x.github.io"}
+</tool_call:fetch_url>
+
+7. SEARCH TEXT ACROSS FILES (Grep):
+<tool_call:search_in_files>
+{"query": "def my_function", "path": "."}
+</tool_call:search_in_files>
+
+8. GET SYSTEM INFO:
+<tool_call:get_system_info>
+{}
+</tool_call:get_system_info>
+
+━━━ BEHAVIORAL RULES ━━━
+- Always use write_file to create files — never just show code in markdown.
+- Always use run_command to execute things — never just say "run this".
+- Chain tool calls: write → run → check output → fix if needed.
+- For git: commit with meaningful messages, push after completing features.
+- For Python: always check syntax with `python -m py_compile file.py` after writing.
+- For projects: always create a proper directory structure, README, requirements.txt.
+- If a command fails: read the error, fix it, run again. Keep going until it works.
+- After finishing a multi-step task: summarize what was done.
+
+━━━ CODE QUALITY STANDARDS ━━━
+- Complete code only — no "add your code here" comments.
+- Proper error handling (try/except, error codes).
+- Type hints for Python.
+- Environment variables for secrets — never hardcode.
+- Tests if the user asks for them.
+- Production-ready: logging, edge cases, input validation.
+
+━━━ CONVERSATION STYLE ━━━
+- Be concise and professional.
+- When you need clarification: ask one focused question.
+- When something is risky/destructive: say so clearly.
+- Format your analysis/explanations with markdown headers.
+- Show tool usage BEFORE the explanation (act first, explain after).
+"""
+
+
+class LocalTools:
+
+    @staticmethod
+    def _resolve(path: str, cwd: str = None) -> str:
+        """Resolve path relative to cwd if not absolute, and expand ~."""
+        expanded = os.path.expanduser(path)
+        if cwd and not os.path.isabs(expanded):
+            return os.path.realpath(os.path.join(cwd, expanded))
+        return os.path.realpath(expanded)
+
+    @staticmethod
+    def view_file(path: str, cwd: str = None) -> str:
+        resolved = LocalTools._resolve(path, cwd)
+        try:
+            if not os.path.exists(resolved):
+                return f"Error: File not found: '{resolved}'"
+            with open(resolved, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+            lines = content.splitlines()
+            if len(lines) > 1000:
+                content = "\n".join(lines[:1000]) + f"\n… [{len(lines)-1000} more lines]"
+            return content
+        except Exception as e:
+            return f"Error reading '{resolved}': {e}"
+
+    @staticmethod
+    def write_file(path: str, content: str, cwd: str = None) -> str:
+        resolved = LocalTools._resolve(path, cwd)
+        try:
+            os.makedirs(os.path.dirname(resolved), exist_ok=True)
+            with open(resolved, "w", encoding="utf-8") as f:
+                f.write(content)
+            return f"Written {len(content):,} bytes to '{resolved}'"
+        except Exception as e:
+            return f"Error writing '{resolved}': {e}"
+
+    @staticmethod
+    def run_command(command: str, cwd: str = None, timeout: int = 120) -> str:
+        """Execute any shell command with full privileges. No restrictions."""
+        work_dir = cwd or os.getcwd()
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                cwd=work_dir,
+                env={**os.environ, "TERM": "xterm-256color"},
+            )
+            parts = []
+            if result.stdout.strip():
+                parts.append(result.stdout.strip())
+            if result.stderr.strip():
+                parts.append(f"[STDERR]\n{result.stderr.strip()}")
+            if result.returncode != 0:
+                parts.append(f"[Exit {result.returncode}]")
+            return "\n\n".join(parts) if parts else "(command completed — no output)"
+        except subprocess.TimeoutExpired:
+            return f"Error: Command timed out after {timeout}s"
+        except Exception as e:
+            return f"Error: {e}"
+
+    @staticmethod
+    def list_dir(path: str = ".", cwd: str = None) -> str:
+        resolved = LocalTools._resolve(path, cwd)
+        try:
+            items = sorted(os.listdir(resolved))
+            lines = []
+            for item in items:
+                full = os.path.join(resolved, item)
+                if os.path.isdir(full):
+                    try:
+                        n = len(os.listdir(full))
+                        lines.append(f"📁  {item}/  ({n} items)")
+                    except PermissionError:
+                        lines.append(f"📁  {item}/  (permission denied)")
+                else:
+                    size = os.path.getsize(full)
+                    lines.append(f"📄  {item}  [{size:,} B]")
+            return "\n".join(lines) if lines else "(empty directory)"
+        except Exception as e:
+            return f"Error listing '{resolved}': {e}"
+
+    @staticmethod
+    def fetch_url(url: str) -> str:
+        """Download text content from a URL (documentation, APIs, etc.)."""
+        try:
+            req = urllib.request.Request(url, headers={'User-Agent': 'NoTrack-CLI'})
+            with urllib.request.urlopen(req, timeout=15) as response:
+                content = response.read().decode('utf-8', errors='ignore')
+                if len(content) > 15000:
+                    content = content[:15000] + "\n… [Content truncated due to length]"
+                return content
+        except Exception as e:
+            return f"Error fetching URL '{url}': {e}"
+
+    @staticmethod
+    def search_in_files(query: str, path: str = ".", extension: str = None, cwd: str = None) -> str:
+        """Search for a text string inside files recursively."""
+        resolved = LocalTools._resolve(path, cwd)
+        results = []
+        try:
+            for root, dirs, files in os.walk(resolved):
+                dirs[:] = [d for d in dirs if not d.startswith('.')]
+                for file in files:
+                    if extension and not file.endswith(extension):
+                        continue
+                    full_path = os.path.join(root, file)
+                    try:
+                        with open(full_path, "r", encoding="utf-8", errors="ignore") as f:
+                            for line_no, line in enumerate(f, 1):
+                                if query.lower() in line.lower():
+                                    rel_path = os.path.relpath(full_path, resolved)
+                                    results.append(f"{rel_path}:{line_no}: {line.strip()}")
+                                    if len(results) >= 40:
+                                        return "\n".join(results) + "\n… [Results truncated at 40 matches]"
+                    except Exception:
+                        continue
+            return "\n".join(results) if results else "No matches found."
+        except Exception as e:
+            return f"Error searching files: {e}"
+
+    @staticmethod
+    def get_system_info() -> str:
+        """Return system specs, disk space, and OS details."""
+        try:
+            total, used, free = shutil.disk_usage("/")
+            info = {
+                "os": platform.system(),
+                "release": platform.release(),
+                "machine": platform.machine(),
+                "python_version": platform.python_version(),
+                "disk_total_gb": round(total / (2**30), 2),
+                "disk_free_gb": round(free / (2**30), 2),
+                "cpu_count": os.cpu_count(),
+            }
+            return json.dumps(info, indent=2)
+        except Exception as e:
+            return f"Error getting system info: {e}"

notrack_cli_agent-0.0.0.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: notrack-cli-agent
+Version: 0.0.0
+Summary: Terminal agent client for NoTrack chat with supervised local tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Requires-Dist: rich>=13.7
+Requires-Dist: prompt-toolkit>=3.0
+
+# NoTrack CLI Agent 0.6.0
+
+Terminal chat client for NoTrack with a supervised local tool loop.
+
+## Install (Linux / Termux / macOS)
+
+```bash
+python -m venv .venv
+# Linux/macOS
+. .venv/bin/activate
+# Termux: activate the venv using the shell command above if supported
+python -m pip install -U pip
+python -m pip install -e .
+notrack
+```
+
+Run a single prompt:
+
+```bash
+notrack ask "Summarize the files in this folder"
+```
+
+## Commands
+
+- `/new` starts a fresh chat context.
+- `/chats` attempts to list conversations visible to this HTTP session.
+- `/resume <chat_id>` selects a previously known chat identifier.
+- `/tools`, `/history`, `/save`, `/pwd`, `/ls`, `/cd <path>`, `/help`, `/exit`.
+
+## Configuration
+
+- `NOTRACK_BASE_URL` defaults to `https://notrack.ai`
+- `NOTRACK_DISPATCH_PATH` defaults to `/api/dispatch`
+- `NOTRACK_MODEL` defaults to `notrack`
+- `NOTRACK_MODE` defaults to `usual`
+
+Example:
+
+```bash
+NOTRACK_DISPATCH_PATH=/api/chat notrack
+```
+
+## Important protocol note
+
+The app's dispatch POST payload is an informed compatibility attempt based on the original project and observed endpoint behavior; NoTrack's current web protocol has not been live-verified in this package. The web site may rely on session cookies, CSRF state, headers, or a changing payload. A successful GET of `/api/chats` does not guarantee that a fresh Python session sees the same anonymous account as Firefox. This client does not copy Firefox credentials or automate Firefox.
+
+## Safety
+
+Local shell and file operations require confirmation by default. Read `RULE.md` before enabling any unattended mode. Treat all agent-generated commands as untrusted until reviewed.
+
+
+## v0.6.2 protocol adjustment
+This build uses the observed `normal` persona, includes `regenerate: false`, and creates anonymous web-style cookies per process. This is based on a public third-party integration example, not a guaranteed official web API contract. Each CLI process creates a fresh anonymous identity; it does not restore Firefox's identity or chats automatically.

notrack_cli_agent-0.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+notrack_cli/__init__.py,sha256=BvQx3CzfQRKK4VLyev4xQnVCeGtri1uvTCj7qRbVWbY,49
+notrack_cli/client.py,sha256=6GBi797I60iNY6lItI1pYpbl_qGN44HBPExDCBafN1M,8576
+notrack_cli/main.py,sha256=9KEFC6mxYxbApbi_Aq4ZOZqA9eOTnOHgHmppY7_ujyg,35380
+notrack_cli/memory.py,sha256=KHaJ99m5ypx0y6RLXWr2hVfTE38u_QClV0PmsSazcEQ,2122
+notrack_cli/parser.py,sha256=I2eDpPAneDwfFmr_SIBzZHs4jlyVNzwa_OHVAy26iEU,1152
+notrack_cli/tools.py,sha256=uTTRRkuTHNa4mIZXhx4d1SgtHjjg_f9t0-V6CGybzMI,9984
+notrack_cli_agent-0.0.0.dist-info/METADATA,sha256=KAUuEthZD9bQe2HIdu52xaz73LhZg5T5a2dS6Ae7IOg,2336
+notrack_cli_agent-0.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+notrack_cli_agent-0.0.0.dist-info/entry_points.txt,sha256=ZLK2VawIjc2kOd6OCEA9_S8z1I2GJGgVH5i0-9zh6To,50
+notrack_cli_agent-0.0.0.dist-info/top_level.txt,sha256=3IINcBiTUEdKBE1_Oi1cpPopqmjc5jkfehxZwkLmEwg,12
+notrack_cli_agent-0.0.0.dist-info/RECORD,,

notrack_cli_agent-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

notrack_cli_agent-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+notrack = notrack_cli.main:main

notrack_cli_agent-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+notrack_cli