pyoxidize 0.2.0__py3-none-any.whl

oxidize/__init__.py

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

oxidize/cli/__init__.py

@@ -0,0 +1,3 @@
+from .main import cli
+
+__all__ = ["cli"]

oxidize/cli/commands/add.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+import click
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+
+
+@click.command("add")
+@click.argument("paths", nargs=-1, required=True, type=click.Path(exists=True))
+def cmd_add(paths: tuple[str, ...]) -> None:
+    """Stage files for the next commit."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    for raw_path in paths:
+        target = Path(raw_path).resolve()
+        if target.is_dir():
+            files = [f for f in target.rglob("*") if f.is_file()]
+        else:
+            files = [target]
+
+        for file_path in files:
+            rel = file_path.relative_to(repo.work_tree).as_posix()
+            oid = repo.db.store_blob(file_path.read_bytes())
+            repo.index.add(rel, oid, file_path)
+            click.echo(f"  staged: {rel}")

oxidize/cli/commands/commit.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import os
+from collections import defaultdict
+
+import click
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+from oxidize.objects.types import Author, Commit, FileMode, Tree, TreeEntry
+
+
+def _build_tree(repo: Repository) -> Tree:
+    entries_by_dir: dict[str, list[tuple[str, str, FileMode]]] = defaultdict(list)
+    for entry in repo.index.entries():
+        parts = entry.path.split("/")
+        if len(parts) == 1:
+            entries_by_dir[""].append((parts[0], entry.oid, FileMode(entry.mode)))
+        else:
+            dir_name = parts[0]
+            file_name = parts[-1]
+            entries_by_dir[dir_name].append((file_name, entry.oid, FileMode(entry.mode)))
+
+    subtrees: dict[str, str] = {}
+    for dir_name, dir_entries in entries_by_dir.items():
+        if dir_name and len(dir_entries) == 1 and dir_entries[0][0] == "__subtree__":
+            continue
+        if not dir_name:
+            continue
+        sub_tree = Tree()
+        for fname, foid, fmode in dir_entries:
+            sub_tree.add(TreeEntry(name=fname, oid=foid, mode=fmode))
+        repo.db.store_tree(sub_tree)
+        subtrees[dir_name] = sub_tree.oid
+
+    root = Tree()
+    for fname, foid, fmode in entries_by_dir.get("", []):
+        root.add(TreeEntry(name=fname, oid=foid, mode=fmode))
+    for dir_name, subtree_oid in sorted(subtrees.items()):
+        root.add(TreeEntry(name=dir_name, oid=subtree_oid, mode=FileMode.DIRECTORY))
+    return root
+
+
+@click.command("commit")
+@click.option("-m", "--message", required=True, help="Commit message")
+@click.option("--agent", default=None, help="Agent that produced this change (e.g. claude-code)")
+def cmd_commit(message: str, agent: str | None = None) -> None:
+    """Record staged changes as a new commit."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    if len(repo.index) == 0:
+        raise click.ClickException("nothing staged -- use `oxidize add` first")
+
+    name = os.environ.get("OXIDE_AUTHOR_NAME") or repo.config.user_name
+    email = os.environ.get("OXIDE_AUTHOR_EMAIL") or repo.config.user_email
+    author = Author(name=name, email=email)
+
+    tree = _build_tree(repo)
+    repo.db.store_tree(tree)
+
+    parents: list[str] = []
+    head = repo.refs.head()
+    if head:
+        parents.append(head)
+
+    commit = Commit(
+        tree_oid=tree.oid,
+        author=author,
+        committer=author,
+        message=message,
+        parents=parents,
+        agent=agent,
+    )
+    repo.db.store_commit(commit)
+    repo.refs.update_head(commit.oid)
+    repo.index.clear()
+
+    short = commit.oid[:8]
+    branch = repo.refs.current_branch() or "HEAD"
+    agent_str = f" [{agent}]" if agent else ""
+    click.echo(f"[{branch} {short}]{agent_str} {message}")

oxidize/cli/commands/diff.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from typing import Any, Mapping
+
+import click
+from rich.console import Console
+from rich.text import Text
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+from oxidize.diff.engine import LineOp, diff_lines
+
+console = Console()
+
+
+@click.command("diff")
+@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.option("--cached", is_flag=True, help="Show staged changes (index vs HEAD)")
+def cmd_diff(paths: tuple[str, ...], cached: bool) -> None:
+    """Show changes between working tree and index (or staged vs HEAD)."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    if cached:
+        _diff_cached(repo, paths)
+    else:
+        _diff_working(repo, paths)
+
+
+def _diff_working(repo: Repository, paths: tuple[str, ...]) -> None:
+    indexed = {e.path: e for e in repo.index.entries()}
+    files = _resolve_paths(repo, paths, indexed)
+
+    for rel in sorted(files):
+        entry = indexed.get(rel)
+        if entry is None:
+            continue
+        disk = repo.work_tree / rel
+        if not disk.exists():
+            console.print(f"[red]deleted: {rel}[/]")
+            continue
+        new_text = disk.read_text(errors="replace")
+        old_blob = repo.db.load_blob(entry.oid)
+        old_text = old_blob.data.decode(errors="replace")
+        if old_text == new_text:
+            continue
+        _print_diff(rel, old_text, new_text)
+
+
+def _diff_cached(repo: Repository, paths: tuple[str, ...]) -> None:
+    head = repo.refs.head()
+    if not head:
+        console.print("[dim]no commits yet[/]")
+        return
+
+    commit = repo.db.load_commit(head)
+    head_tree = repo.db.load_tree(commit.tree_oid)
+    head_files = {e.name: e for e in head_tree}
+
+    indexed = {e.path: e for e in repo.index.entries()}
+    files = _resolve_paths(repo, paths, indexed)
+
+    for rel in sorted(files):
+        entry = indexed.get(rel)
+        head_entry = head_files.get(rel)
+        if entry and not head_entry:
+            console.print(f"[green]new file: {rel}[/]")
+        elif not entry and head_entry:
+            console.print(f"[red]deleted: {rel}[/]")
+        elif entry and head_entry:
+            old_blob = repo.db.load_blob(head_entry.oid)
+            new_blob = repo.db.load_blob(entry.oid)
+            if old_blob.data != new_blob.data:
+                _print_diff(
+                    rel,
+                    old_blob.data.decode(errors="replace"),
+                    new_blob.data.decode(errors="replace"),
+                )
+
+
+def _resolve_paths(
+    repo: Repository, paths: tuple[str, ...], indexed: Mapping[str, Any]
+) -> set[str]:
+    if paths:
+        result: set[str] = set()
+        for raw in paths:
+            p = Path(raw).resolve()
+            if p.is_dir():
+                for f in p.rglob("*"):
+                    rel = f.relative_to(repo.work_tree).as_posix()
+                    if rel in indexed:
+                        result.add(rel)
+            else:
+                rel = p.relative_to(repo.work_tree).as_posix()
+                result.add(rel)
+        return result
+    return set(indexed.keys())
+
+
+def _print_diff(path: str, old: str, new: str) -> None:
+    console.print(f"\n[bold]diff --a/a b/{path}[/]")
+    diff_result = diff_lines(old, new)
+    for dl in diff_result:
+        if dl.op == LineOp.EQUAL:
+            console.print(f" {dl.content}", end="")
+        elif dl.op == LineOp.INSERT:
+            line = Text(f"+{dl.content}")
+            line.stylize("green")
+            console.print(line, end="")
+        elif dl.op == LineOp.DELETE:
+            line = Text(f"-{dl.content}")
+            line.stylize("red")
+            console.print(line, end="")
+    if diff_result and not diff_result[-1].content.endswith("\n"):
+        console.print()

oxidize/cli/commands/init.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+import click
+
+from oxidize.core.repository import Repository
+
+
+@click.command("init")
+@click.argument("path", default=".", type=click.Path())
+def cmd_init(path: str) -> None:
+    """Initialize a new oxidize repository."""
+    target = Path(path).resolve()
+    target.mkdir(parents=True, exist_ok=True)
+    try:
+        repo = Repository.init(target)
+        click.echo(f"Initialized empty oxidize repository in {repo.oxidize_dir}")
+    except FileExistsError as e:
+        raise click.ClickException(str(e))

oxidize/cli/commands/log.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import datetime
+
+import click
+from rich.console import Console
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+
+console = Console()
+
+
+@click.command("log")
+@click.option("-n", "--count", default=20, help="Max commits to show")
+def cmd_log(count: int) -> None:
+    """Show commit history."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    head = repo.refs.head()
+    if not head:
+        click.echo("No commits yet.")
+        return
+
+    oid: str | None = head
+    shown = 0
+    while oid and shown < count:
+        commit = repo.db.load_commit(oid)
+        dt = datetime.datetime.fromtimestamp(commit.author.timestamp)
+        date_str = dt.strftime("%a %b %d %H:%M:%S %Y")
+
+        console.print(f"[yellow]commit {oid}[/]")
+        console.print(f"Author: {commit.author.name} <{commit.author.email}>")
+        console.print(f"Date:   {date_str}\n")
+        console.print(f"    {commit.message}\n")
+
+        oid = commit.parents[0] if commit.parents else None
+        shown += 1

oxidize/cli/commands/scan.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+from oxidize.security.scanner import scan_directory, scan_file
+
+console = Console()
+
+
+@click.command("scan")
+@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.option("--staged", is_flag=True, help="Scan only staged files")
+def cmd_scan(paths: tuple[str, ...], staged: bool) -> None:
+    """Scan for secrets and credentials."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    findings: list[dict[str, str | int]] = []
+
+    if staged:
+        for entry in repo.index.entries():
+            full = repo.work_tree / entry.path
+            if full.exists():
+                findings.extend(scan_file(full, repo.work_tree))
+    elif paths:
+        for raw in paths:
+            p = Path(raw).resolve()
+            if p.is_dir():
+                findings.extend(scan_directory(p))
+            else:
+                findings.extend(scan_file(p, repo.work_tree))
+    else:
+        findings.extend(scan_directory(repo.work_tree))
+
+    if not findings:
+        console.print("[green]No secrets found.[/]")
+        return
+
+    console.print(f"\n[red bold]Found {len(findings)} potential secret(s):[/]\n")
+    for f in findings:
+        console.print(
+            f"  [yellow]{f['type']}[/] in [cyan]{f['file']}[/] line {f['line']}: {f['match']}"
+        )
+    console.print()

oxidize/cli/commands/status.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+
+console = Console()
+
+_IGNORE = {".oxidize", ".git", "__pycache__", ".DS_Store"}
+
+
+def _walk(root: Path) -> list[Path]:
+    result = []
+    for p in sorted(root.rglob("*")):
+        if any(part in _IGNORE for part in p.parts):
+            continue
+        if p.is_file():
+            result.append(p)
+    return result
+
+
+@click.command("status")
+def cmd_status() -> None:
+    """Show working tree status."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    branch = repo.refs.current_branch() or "(detached HEAD)"
+    console.print(f"On branch [bold cyan]{branch}[/]")
+
+    staged: list[str] = []
+    modified: list[str] = []
+    untracked: list[str] = []
+
+    indexed_paths = {e.path for e in repo.index.entries()}
+    disk_files = _walk(repo.work_tree)
+
+    for file_path in disk_files:
+        rel = file_path.relative_to(repo.work_tree).as_posix()
+        entry = repo.index.get(rel)
+        if entry is None:
+            untracked.append(rel)
+        elif entry.is_stale(file_path):
+            modified.append(rel)
+
+    for path in indexed_paths:
+        full = repo.work_tree / path
+        if not full.exists():
+            staged.append(f"deleted: {path}")
+        else:
+            staged.append(path)
+
+    if not staged and not modified and not untracked:
+        console.print("nothing to commit, working tree clean")
+        return
+
+    if staged:
+        console.print("\n[green]Changes staged for commit:[/]")
+        for p in staged:
+            console.print(f"        [green]{p}[/]")
+
+    if modified:
+        console.print("\n[yellow]Changes not staged for commit:[/]")
+        for p in modified:
+            console.print(f"        [yellow]modified: {p}[/]")
+
+    if untracked:
+        console.print("\n[dim]Untracked files:[/]")
+        for p in untracked:
+            console.print(f"        [dim]{p}[/]")

oxidize/cli/commands/undo.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import time
+
+import click
+from rich.console import Console
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+from oxidize.undo.journal import Journal
+from oxidize.undo.reverser import UndoManager
+
+console = Console()
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def cmd_undo(ctx: click.Context) -> None:
+    """Undo the last operation."""
+    if ctx.invoked_subcommand is None:
+        _do_undo(1)
+
+
+@cmd_undo.command("last")
+def cmd_undo_last() -> None:
+    """Undo the last operation."""
+    _do_undo(1)
+
+
+@cmd_undo.command("count")
+@click.argument("n", type=int)
+def cmd_undo_count(n: int) -> None:
+    """Undo the last N operations."""
+    _do_undo(n)
+
+
+@cmd_undo.command("journal")
+def cmd_journal() -> None:
+    """Show operation journal."""
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    journal = Journal(repo.oxidize_dir / "journal.json")
+    entries = journal.entries()
+
+    if not entries:
+        click.echo("No operations recorded.")
+        return
+
+    for i, entry in enumerate(reversed(entries)):
+        dt = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(entry.timestamp))
+        click.echo(f"  {i + 1}. [{dt}] {entry.op} - {entry.data}")
+
+
+def _do_undo(count: int) -> None:
+    try:
+        repo = Repository.discover()
+    except RepositoryNotFound as e:
+        raise click.ClickException(str(e))
+
+    mgr = UndoManager(repo)
+    messages = mgr.undo(count)
+    for msg in messages:
+        click.echo(msg)

oxidize/cli/main.py

@@ -0,0 +1,26 @@
+import click
+
+from oxidize.cli.commands.add import cmd_add
+from oxidize.cli.commands.commit import cmd_commit
+from oxidize.cli.commands.diff import cmd_diff
+from oxidize.cli.commands.init import cmd_init
+from oxidize.cli.commands.log import cmd_log
+from oxidize.cli.commands.scan import cmd_scan
+from oxidize.cli.commands.status import cmd_status
+from oxidize.cli.commands.undo import cmd_undo
+
+
+@click.group()
+@click.version_option(package_name="oxidize")
+def cli() -> None:
+    """oxidize -- a version control system with semantic awareness."""
+
+
+cli.add_command(cmd_init, "init")
+cli.add_command(cmd_add, "add")
+cli.add_command(cmd_status, "status")
+cli.add_command(cmd_commit, "commit")
+cli.add_command(cmd_log, "log")
+cli.add_command(cmd_diff, "diff")
+cli.add_command(cmd_scan, "scan")
+cli.add_command(cmd_undo, "undo")

oxidize/cli/repl.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import NestedCompleter, PathCompleter
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.styles import Style
+
+from oxidize.core.repository import Repository, RepositoryNotFound
+
+_STYLE = Style.from_dict(
+    {
+        "toolbar": "#ffffff bg:#333333 bold",
+        "prompt": "#00aa00 bold",
+    }
+)
+
+_HISTORY_PATH = Path.home() / ".oxidize_history"
+
+
+def _get_toolbar() -> HTML:
+    try:
+        repo = Repository.discover()
+        branch = repo.refs.current_branch() or "detached"
+        staged = len(repo.index)
+        head = repo.refs.head()
+        short = head[:8] if head else "none"
+        return HTML(
+            f" <b>({branch})</b> "
+            f"staged:<b>{staged}</b> "
+            f"HEAD:<b>{short}</b> "
+            f"| <b>Ctrl-D</b> exit | <b>help</b> for commands"
+        )
+    except RepositoryNotFound:
+        return HTML(" <b>no repo</b> | <b>oxidize init</b> to create one | <b>Ctrl-D</b> exit")
+
+
+def _build_completer() -> NestedCompleter:
+    command_names = [
+        "init",
+        "add",
+        "status",
+        "commit",
+        "log",
+        "diff",
+        "scan",
+        "help",
+        "exit",
+        "quit",
+        "undo",
+        "redo",
+        "branch",
+        "agent",
+        "blame",
+        "merge",
+        "show",
+    ]
+    alias_map: dict[str, None] = {
+        "s": None,
+        "c": None,
+        "a": None,
+        "l": None,
+        "d": None,
+        "q": None,
+    }
+    nested: dict[str, PathCompleter | None] = {cmd: PathCompleter() for cmd in command_names}
+    nested.update(alias_map)
+    return NestedCompleter.from_nested_dict(nested)
+
+
+_ALIASES: dict[str, str] = {
+    "s": "status",
+    "c": "commit",
+    "a": "add",
+    "l": "log",
+    "d": "diff",
+    "q": "exit",
+}
+
+
+def _dispatch(line: str) -> str | None:
+    parts = line.strip().split()
+    if not parts:
+        return None
+
+    cmd = _ALIASES.get(parts[0], parts[0])
+    args = parts[1:]
+
+    if cmd in ("exit", "quit"):
+        return "__EXIT__"
+
+    if cmd == "help":
+        return _help_text()
+
+    try:
+        from click.testing import CliRunner
+        from oxidize.cli.main import cli
+
+        runner = CliRunner()
+        result = runner.invoke(cli, [cmd] + args, catch_exceptions=False)
+        return result.output
+    except SystemExit as e:
+        return f"(exit code {e.code})" if e.code else None
+    except Exception as e:
+        return f"error: {e}"
+
+
+def _help_text() -> str:
+    return """\
+Available commands:
+  init [path]       Initialize a new repository
+  add <paths...>    Stage files for commit
+  status (s)        Show working tree status
+  commit -m "msg"   Record staged changes (c)
+  log [-n N]        Show commit history (l)
+  diff [paths]      Show changes (d)
+  scan [paths]      Scan for secrets
+  help              Show this help
+  exit (q)          Exit the shell
+
+Aliases: s=status, c=commit, a=add, l=log, d=diff, q=exit
+"""
+
+
+def main() -> None:
+    import sys
+
+    args = sys.argv[1:]
+    if args:
+        from oxidize.cli.main import cli
+
+        cli(args, standalone_mode=True)
+        return
+
+    session: PromptSession[str] = PromptSession(
+        history=FileHistory(str(_HISTORY_PATH)),
+        completer=_build_completer(),
+        complete_while_typing=True,
+        style=_STYLE,
+        bottom_toolbar=_get_toolbar,
+    )
+
+    print("oxidize interactive shell v0.2.0")
+    print("Type 'help' for commands, Ctrl-D to exit.\n")
+
+    while True:
+        try:
+            text = session.prompt("oxi> ")
+        except KeyboardInterrupt:
+            continue
+        except EOFError:
+            break
+
+        text = text.strip()
+        if not text:
+            continue
+
+        output = _dispatch(text)
+        if output == "__EXIT__":
+            break
+        if output:
+            print(output, end="" if output.endswith("\n") else "\n")
+
+
+if __name__ == "__main__":
+    main()

oxidize/core/__init__.py

@@ -0,0 +1,5 @@
+from .repository import Repository, RepositoryNotFound
+from .config import Config
+from .refs import RefStore
+
+__all__ = ["Repository", "RepositoryNotFound", "Config", "RefStore"]