ghostcode-canary 0.1.25-canary.0

package/src/ghostcode/core/commands.py

@@ -0,0 +1,55 @@
+import dataclasses
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+
+@dataclasses.dataclass
+class Command:
+    name: str
+    description: str
+    handler: Callable[..., Coroutine[Any, Any, str | None]]
+    usage: str = ""
+    aliases: list[str] | None = None
+    category: str = "general"
+
+    def __post_init__(self):
+        if not self.usage:
+            self.usage = f"/{self.name}"
+
+
+_command_registry: dict[str, Command] = {}
+
+
+def register(cmd: Command):
+    _command_registry[cmd.name] = cmd
+    for alias in (cmd.aliases or []):
+        _command_registry[alias] = cmd
+
+
+def get_command(name: str) -> Command | None:
+    return _command_registry.get(name.lstrip("/").lower().split()[0])
+
+
+def list_commands(category: str | None = None) -> list[Command]:
+    cmds = list(_command_registry.values())
+    if category:
+        cmds = [c for c in cmds if c.category == category]
+    seen = {}
+    for c in cmds:
+        if c.name not in seen:
+            seen[c.name] = c
+    return list(seen.values())
+
+
+def all_commands() -> dict[str, Command]:
+    deduped = {}
+    for name, cmd in _command_registry.items():
+        deduped[name] = cmd
+    return deduped
+
+
+async def dispatch(cmd_name: str, args: list[str], ctx: dict | None = None) -> str | None:
+    cmd = get_command(cmd_name)
+    if not cmd:
+        return None
+    return await cmd.handler(args, ctx or {})

package/src/ghostcode/core/file_ops.py

@@ -0,0 +1,127 @@
+import re
+from pathlib import Path
+
+OUTPUT_DIR = "ghostcode_gen"
+
+
+def _detect_name(code: str, lang: str) -> str:
+    for pat in [
+        r"^(?:def|class|async def)\s+(\w+)",
+        r"(?:def|class)\s+(\w+)",
+        r"(?:export\s+)?(?:function|const)\s+(\w+)",
+        r"^(?:fn|fun|func)\s+(\w+)",
+        r"^(?:public\s+)?(?:class|interface|trait)\s+(\w+)",
+    ]:
+        m = re.search(pat, code, re.MULTILINE)
+        if m:
+            return m.group(1)
+    return None
+
+
+_EXT_MAP = {
+    "python": "py", "py": "py",
+    "javascript": "js", "js": "js", "node": "js",
+    "typescript": "ts", "ts": "ts",
+    "jsx": "jsx", "tsx": "tsx",
+    "go": "go", "golang": "go",
+    "rust": "rs", "rs": "rs",
+    "ruby": "rb", "rb": "rb",
+    "java": "java",
+    "kotlin": "kt", "kt": "kt",
+    "c": "c", "cpp": "cpp", "c++": "cpp",
+    "h": "h", "hpp": "hpp",
+    "html": "html", "htm": "html",
+    "css": "css", "scss": "scss", "sass": "scss",
+    "bash": "sh", "sh": "sh", "shell": "sh", "zsh": "sh",
+    "sql": "sql",
+    "yaml": "yaml", "yml": "yaml",
+    "json": "json",
+    "toml": "toml",
+    "markdown": "md", "md": "md",
+    "dockerfile": "Dockerfile",
+    "makefile": "Makefile",
+    "swift": "swift",
+    "php": "php",
+    "r": "r",
+    "lua": "lua",
+}
+
+
+def _ext_for_lang(lang: str) -> str:
+    lang = lang.lower().strip()
+    return _EXT_MAP.get(lang, lang)
+
+
+_counter = 0
+
+
+def _next_fallback(lang: str) -> str:
+    global _counter
+    _counter += 1
+    ext = _ext_for_lang(lang)
+    return f"code_{_counter}.{ext}"
+
+
+def autosave_code_blocks(content: str) -> list[dict]:
+    blocks = extract_code_blocks(content)
+    saved = []
+    out_dir = Path(OUTPUT_DIR)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    for i, (lang, code) in enumerate(blocks):
+        name = _detect_name(code, lang)
+        if name:
+            ext = _ext_for_lang(lang)
+            filename = f"{name}.{ext}" if ext != lang else name
+        else:
+            filename = _next_fallback(lang)
+
+        path = out_dir / filename
+
+        if path.exists():
+            stem = path.stem
+            path = out_dir / f"{stem}_{i+1}{path.suffix}"
+
+        path.write_text(code, encoding="utf-8")
+        saved.append({
+            "path": str(path),
+            "size": len(code),
+            "language": lang,
+        })
+
+    return saved
+
+
+def safe_write(path: str, content: str, backup: bool = True) -> dict:
+    p = Path(path).expanduser().resolve()
+    if p.exists() and backup:
+        bak = p.with_suffix(p.suffix + ".bak")
+        import shutil
+        shutil.copy2(str(p), str(bak))
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(content, encoding="utf-8")
+    return {"path": str(p), "size": len(content)}
+
+
+def read_file(path: str) -> str | None:
+    p = Path(path).expanduser().resolve()
+    if not p.exists():
+        return None
+    return p.read_text(encoding="utf-8")
+
+
+def extract_code_blocks(text: str) -> list[tuple[str, str]]:
+    blocks = []
+    lines = text.splitlines()
+    i = 0
+    while i < len(lines):
+        if lines[i].strip().startswith("```"):
+            lang = lines[i].strip().removeprefix("```").strip()
+            code = []
+            i += 1
+            while i < len(lines) and not lines[i].strip().startswith("```"):
+                code.append(lines[i])
+                i += 1
+            blocks.append((lang, "\n".join(code)))
+        i += 1
+    return blocks

package/src/ghostcode/core/hooks.py

@@ -0,0 +1,122 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+
+HOOKS_FILE = ".ghostcode/hooks.json"
+
+
+class HookRegistry:
+    def __init__(self):
+        self._before: list[dict] = []
+        self._after: list[dict] = []
+        self._stop: dict | None = None
+        self._load()
+
+    def _load(self):
+        p = Path.cwd() / HOOKS_FILE
+        if not p.exists():
+            return
+        try:
+            data = json.loads(p.read_text())
+            self._before = data.get("before_tool", [])
+            self._after = data.get("after_tool", [])
+            self._stop = data.get("stop_hook", None)
+        except (json.JSONDecodeError, Exception):
+            pass
+
+    def _save(self):
+        p = Path.cwd() / HOOKS_FILE
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(json.dumps({
+            "before_tool": self._before,
+            "after_tool": self._after,
+            "stop_hook": self._stop,
+        }, indent=2))
+
+    def set_hook(self, hook_type: str, config: dict):
+        if hook_type == "before_tool":
+            self._before.append(config)
+        elif hook_type == "after_tool":
+            self._after.append(config)
+        elif hook_type == "stop_hook":
+            self._stop = config
+        self._save()
+
+    def remove_hook(self, hook_type: str, index: int = 0) -> bool:
+        if hook_type == "before_tool" and 0 <= index < len(self._before):
+            self._before.pop(index)
+            self._save()
+            return True
+        if hook_type == "after_tool" and 0 <= index < len(self._after):
+            self._after.pop(index)
+            self._save()
+            return True
+        if hook_type == "stop_hook" and self._stop:
+            self._stop = None
+            self._save()
+            return True
+        return False
+
+    def get_hooks(self, hook_type: str) -> list[dict]:
+        if hook_type == "before_tool":
+            return self._before
+        if hook_type == "after_tool":
+            return self._after
+        if hook_type == "stop_hook":
+            return [self._stop] if self._stop else []
+        return []
+
+    def run_before(self, tool_name: str, args: dict) -> tuple[bool, str]:
+        for hook in self._before:
+            condition = hook.get("condition", "")
+            if condition and condition not in json.dumps({"tool": tool_name, "args": args}):
+                continue
+            command = hook.get("command", "")
+            if command:
+                try:
+                    result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=10)
+                    if result.returncode != 0:
+                        return False, result.stderr[:200]
+                except subprocess.TimeoutExpired:
+                    return False, "Hook timed out"
+                except Exception as e:
+                    return False, str(e)
+        return True, ""
+
+    def run_after(self, tool_name: str, args: dict, result: str) -> str:
+        for hook in self._after:
+            condition = hook.get("condition", "")
+            if condition and condition not in json.dumps({"tool": tool_name, "args": args}):
+                continue
+            command = hook.get("command", "")
+            if command:
+                try:
+                    subprocess.run(command, shell=True, capture_output=True, text=True, timeout=10)
+                except Exception:
+                    pass
+        return result
+
+    def check_stop(self) -> str | None:
+        if not self._stop:
+            return None
+        command = self._stop.get("command", "")
+        if command:
+            try:
+                result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=5)
+                if result.returncode == 0:
+                    return self._stop.get("message", "Stop hook triggered")
+            except Exception:
+                pass
+        return None
+
+    def summary(self) -> dict:
+        return {
+            "before_tool": len(self._before),
+            "after_tool": len(self._after),
+            "stop_hook": 1 if self._stop else 0,
+        }
+
+
+hook_registry = HookRegistry()

package/src/ghostcode/core/memory.py

@@ -0,0 +1,137 @@
+from pathlib import Path
+import yaml
+import re
+
+
+MEMORY_DIR = ".ghostcode/memory"
+MEMORY_TYPES = ("user", "feedback", "project", "reference")
+
+_frontmatter_re = re.compile(r"^---\s*\n(.*?)\n---\s*\n?(.*)", re.DOTALL)
+
+
+def _memories_dir() -> Path:
+    return Path.cwd() / MEMORY_DIR
+
+
+def _memory_path(name: str) -> Path:
+    return _memories_dir() / f"{name}.md"
+
+
+def _list_memory_files() -> list[Path]:
+    d = _memories_dir()
+    if not d.exists():
+        return []
+    return sorted(d.glob("*.md"))
+
+
+def load_memory(name: str) -> dict | None:
+    p = _memory_path(name)
+    if not p.exists():
+        return None
+    raw = p.read_text(encoding="utf-8")
+    m = _frontmatter_re.match(raw)
+    if not m:
+        return {"name": name, "content": raw.strip(), "metadata": {}}
+    metadata = yaml.safe_load(m.group(1)) or {}
+    content = m.group(2).strip()
+    return {"name": metadata.get("name", name), "description": metadata.get("description", ""), "metadata": metadata.get("metadata", {}), "content": content}
+
+
+def search_memory(query: str) -> list[dict]:
+    q = query.lower()
+    results = []
+    for fp in _list_memory_files():
+        entry = load_memory(fp.stem)
+        if not entry:
+            continue
+        text = f"{entry.get('name', '')} {entry.get('description', '')} {entry.get('content', '')}".lower()
+        if q in text:
+            results.append(entry)
+    return results
+
+
+def save_memory(name: str, content: str, metadata: dict | None = None) -> dict:
+    _memories_dir().mkdir(parents=True, exist_ok=True)
+    safe_name = name.lower().replace(" ", "-")
+    safe_name = "".join(c for c in safe_name if c.isalnum() or c in "-_")
+    if not safe_name:
+        safe_name = "memory"
+
+    slug = safe_name
+    path = _memory_path(slug)
+    if path.exists():
+        for i in range(1, 100):
+            alt = f"{slug}-{i}"
+            p = _memory_path(alt)
+            if not p.exists():
+                slug, path = alt, p
+                break
+
+    meta = metadata or {}
+    mtype = meta.get("type", "reference")
+    if mtype not in MEMORY_TYPES:
+        mtype = "reference"
+
+    desc = meta.get("description", content[:80] if len(content) > 80 else content)
+    pinned = meta.get("pinned", False)
+
+    frontmatter = {
+        "name": slug,
+        "description": desc,
+        "metadata": {"type": mtype},
+    }
+    if pinned:
+        frontmatter["metadata"]["pinned"] = True
+
+    raw = f"---\n{yaml.dump(frontmatter, default_flow_style=False).strip()}\n---\n\n{content}\n"
+    path.write_text(raw, encoding="utf-8")
+    return {"path": str(path), "slug": slug, "type": mtype, "bytes": len(raw)}
+
+
+def delete_memory(name: str) -> bool:
+    p = _memory_path(name)
+    if p.exists():
+        p.unlink()
+        return True
+    return False
+
+
+def list_memories(mtype: str | None = None) -> list[dict]:
+    results = []
+    for fp in _list_memory_files():
+        entry = load_memory(fp.stem)
+        if not entry:
+            continue
+        if mtype and entry.get("metadata", {}).get("type") != mtype:
+            continue
+        results.append(entry)
+    return results
+
+
+def update_memory(name: str, content: str | None = None, metadata: dict | None = None) -> dict | None:
+    existing = load_memory(name)
+    if not existing:
+        return None
+    new_meta = existing.get("metadata", {})
+    if metadata:
+        mtype = metadata.get("type")
+        if mtype and mtype in MEMORY_TYPES:
+            new_meta["type"] = mtype
+        pinned = metadata.get("pinned")
+        if pinned is not None:
+            new_meta["pinned"] = pinned
+    save_memory(name, content or existing["content"], {"type": new_meta.get("type", "reference"), "description": existing.get("description", ""), "pinned": new_meta.get("pinned", False)})
+    return load_memory(name)
+
+
+def count_memories() -> int:
+    return len(_list_memory_files())
+
+
+def memory_summary() -> dict:
+    memories = list_memories()
+    by_type: dict[str, int] = {}
+    for m in memories:
+        t = m.get("metadata", {}).get("type", "unknown")
+        by_type[t] = by_type.get(t, 0) + 1
+    return {"total": len(memories), "by_type": by_type}

package/src/ghostcode/core/prompt.py

@@ -0,0 +1,73 @@
+import re
+
+from ghostcode.agents import get_system_prompt
+from ghostcode.core.reminders import build_reminders, format_reminders
+
+SYSTEM_PROMPT = get_system_prompt("code")
+
+_GREETINGS = re.compile(
+    r"^(hi|hello|hey|yo|sup|hola|hai|hallo|heyy?|helloo?|good\s* morning|good\s* evening|what'?s up|howdy|hey\s+there)\s*[.!]*\s*$",
+    re.IGNORECASE,
+)
+
+_THANK_YOUS = re.compile(
+    r"^(thanks|thank\s*you|ty|thx|tysm|thank\s*you\s*so\s*much|cheers|appreciate\s*it)\s*[.!]*\s*$",
+    re.IGNORECASE,
+)
+
+_AGREEMENTS = re.compile(
+    r"^(ok|okay|k|got it|i see|understood|sure|yes|yeah|yep|alright|fine|makes sense)\s*[.!]*\s*$",
+    re.IGNORECASE,
+)
+
+_WHO_MADE = re.compile(
+    r"^(who\s+)?((made|created|built|develop(ed)?|program(med)?|wrote|own(s)?)\s+(you|ghostcode)|(is\s+your\s+(creator|author|maker)))(\?)?\s*$",
+    re.IGNORECASE,
+)
+
+
+def detect_greeting(text: str) -> str | None:
+    t = text.strip().lower()
+    if _WHO_MADE.match(t):
+        return "GhostCode was built by [bold]TheDarkGhost Team[/bold]. The underlying LLM is by its respective provider (e.g., Meta for Llama, Mistral AI for Mistral, etc.)."
+    if _GREETINGS.match(t):
+        return "hi"
+    if _THANK_YOUS.match(t):
+        return "np"
+    if _AGREEMENTS.match(t):
+        return "👍"
+    return None
+
+
+def build_system_content(agent: str = "code", **context) -> str:
+    prompt = get_system_prompt(agent)
+    reminders = build_reminders(**context)
+    if reminders:
+        sep = "\n\n" if agent == "code" else "\n"
+        return prompt + sep + format_reminders(reminders)
+    return prompt
+
+
+def build_messages(
+    history: list[dict],
+    user_prompt: str,
+    agent: str = "code",
+    plan_mode: bool = False,
+    file_state: dict | None = None,
+    hook_state: dict | None = None,
+    memory_count: int = 0,
+    task_count: int = 0,
+) -> list[dict]:
+    content = build_system_content(
+        agent=agent,
+        plan_mode=plan_mode,
+        file_state=file_state,
+        hook_state=hook_state,
+        memory_count=memory_count,
+        task_count=task_count,
+    )
+    messages = [{"role": "system", "content": content}]
+    for entry in history:
+        messages.append({"role": entry["role"], "content": entry["content"]})
+    messages.append({"role": "user", "content": user_prompt})
+    return messages

package/src/ghostcode/core/reminders.py

@@ -0,0 +1,61 @@
+import os
+from pathlib import Path
+
+
+SYSTEM_REMINDERS = {
+    "file_empty": "<system-reminder>Warning: the file exists but the contents are empty.</system-reminder>",
+    "file_truncated": "Note: The file was too large and has been truncated. Use read_file to read more of the file if you need.",
+    "file_range_exceeded": "<system-reminder>Warning: the file exists but is shorter than the provided offset.</system-reminder>",
+    "exited_plan_mode": "## Exited Plan Mode\n\nYou have exited plan mode. You can now make edits, run tools, and take actions.",
+    "session_continued": "This session is being continued from another machine. Application state may have changed.",
+}
+
+
+def reminder(key: str, **kwargs) -> str:
+    tmpl = SYSTEM_REMINDERS.get(key)
+    if not tmpl:
+        return ""
+    if kwargs:
+        return tmpl.format(**kwargs)
+    return tmpl
+
+
+def build_reminders(
+    plan_mode: bool = False,
+    file_state: dict | None = None,
+    hook_state: dict | None = None,
+    memory_count: int = 0,
+    task_count: int = 0,
+) -> list[str]:
+    result = []
+    if plan_mode:
+        result.append(
+            "## Plan mode is active\n\n"
+            "You are in read-only plan mode. DO NOT write or edit any files. "
+            "Explore the codebase, understand patterns, and design an implementation strategy. "
+            "When ready, describe your plan to the user."
+        )
+    if file_state:
+        if file_state.get("empty"):
+            result.append(reminder("file_empty"))
+        if file_state.get("truncated"):
+            result.append(reminder("file_truncated"))
+        if file_state.get("range_exceeded"):
+            result.append(reminder("file_range_exceeded"))
+        if file_state.get("modified_by_user"):
+            result.append(
+                "Note: A file was modified externally (by user or linter). "
+                "This change was intentional — don't revert it unless asked."
+            )
+    if hook_state:
+        if hook_state.get("blocking_error"):
+            result.append(f"Hook blocking error: {hook_state['blocking_error']}")
+        if hook_state.get("success"):
+            result.append(f"Hook success: {hook_state['success']}")
+    return result
+
+
+def format_reminders(reminders_list: list[str]) -> str:
+    if not reminders_list:
+        return ""
+    return "\n\n".join(reminders_list)

package/src/ghostcode/core/security.py

@@ -0,0 +1,119 @@
+import os
+import re
+from pathlib import Path
+
+
+DENY_FILE = ".ghostcode/deny.json"
+
+
+def _load_deny_rules() -> list[dict]:
+    import json
+    p = Path.cwd() / DENY_FILE
+    if not p.exists():
+        return []
+    try:
+        return json.loads(p.read_text())
+    except (json.JSONDecodeError, Exception):
+        return []
+
+
+def _save_deny_rules(rules: list[dict]):
+    import json
+    p = Path.cwd() / DENY_FILE
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(rules, indent=2))
+
+
+def is_action_denied(tool_name: str, args: dict) -> tuple[bool, str]:
+    rules = _load_deny_rules()
+    for rule in rules:
+        pattern = rule.get("pattern", "")
+        if not pattern:
+            continue
+        if tool_name == "run_command":
+            cmd = args.get("command", "")
+            if re.search(pattern, cmd):
+                return True, rule.get("reason", "denied by pattern")
+        elif tool_name in ("write_file", "edit_file", "read_file", "list_files"):
+            path = args.get("file_path", "") or args.get("path", "")
+            if re.search(pattern, path):
+                return True, rule.get("reason", "denied by pattern")
+        elif tool_name == "grep_search":
+            pat = args.get("pattern", "")
+            inc = args.get("include", "")
+            combined = f"{pat} {inc}"
+            if re.search(pattern, combined):
+                return True, rule.get("reason", "denied by pattern")
+    return False, ""
+
+
+def add_deny_rule(pattern: str, reason: str = ""):
+    rules = _load_deny_rules()
+    rules.append({"pattern": pattern, "reason": reason})
+    _save_deny_rules(rules)
+
+
+def remove_deny_rule(pattern: str) -> bool:
+    rules = _load_deny_rules()
+    new_rules = [r for r in rules if r.get("pattern") != pattern]
+    if len(new_rules) == len(rules):
+        return False
+    _save_deny_rules(new_rules)
+    return True
+
+
+def list_deny_rules() -> list[dict]:
+    return _load_deny_rules()
+
+
+DESTRUCTIVE_TOOLS = {"write_file", "edit_file", "run_command"}
+OUTWARD_FACING_PATTERNS = [r"git\s+push", r"gh\s+pr", r"git\s+commit", r"npm\s+publish", r"pip(\s+|.*\s+)publish", r"kubectl\s+(apply|delete|create)", r"aws\s+"]
+
+
+def is_reversible(args: dict) -> bool:
+    return True
+
+
+def needs_confirmation(tool_name: str, args: dict) -> tuple[bool, str]:
+    if tool_name in ("write_file", "edit_file"):
+        path = args.get("file_path", "")
+        p = Path(path)
+        if p.exists():
+            return True, f"File already exists: {path}"
+    if tool_name == "run_command":
+        cmd = args.get("command", "")
+        if any(re.search(pat, cmd) for pat in OUTWARD_FACING_PATTERNS):
+            return True, f"Command may affect external systems: {cmd[:80]}"
+        destructive_words = ["rm ", "rm -rf", "rmdir", "del ", "rd ", "format ", "mkfs", "dd "]
+        if any(w in cmd for w in destructive_words):
+            return True, f"Destructive command: {cmd[:80]}"
+    if tool_name in ("delete_memory",):
+        return True, f"Deleting memory: {args.get('name', '')}"
+    return False, ""
+
+
+SECRET_PATTERNS = [
+    r"(?:api[_-]?key|apikey|secret|token|password|passwd|credential)[\s\"'=:]+[A-Za-z0-9_\-\.]{16,}",
+    r"sk-[A-Za-z0-9]{32,}",
+    r"ghp_[A-Za-z0-9]{36}",
+    r"gho_[A-Za-z0-9]{36}",
+    r"ghu_[A-Za-z0-9]{36}",
+    r"xox[bpras]-[A-Za-z0-9\-]{10,}",
+    r"AKIA[0-9A-Z]{16}",
+]
+
+
+def scan_for_secrets(content: str) -> list[str]:
+    findings = []
+    for pat in SECRET_PATTERNS:
+        matches = re.findall(pat, content)
+        for m in matches:
+            if m not in findings:
+                findings.append(m)
+    return findings
+
+
+def redact_secrets(content: str) -> str:
+    for pat in SECRET_PATTERNS:
+        content = re.sub(pat, lambda m: m.group(0)[:4] + "..." + m.group(0)[-4:], content)
+    return content