datavault-cli 1.0.0__py3-none-any.whl

chain.py

@@ -0,0 +1,173 @@
+import hashlib
+import json
+import os
+
+HISTORY_FILE = ".datavault/history.json"
+CHAIN_FILE   = ".datavault/chain.json"
+
+
+def compute_chain_hash(file_hash, prev_chain_hash, version_id, timestamp, author, message):
+    chain_input = "|".join([file_hash, prev_chain_hash, version_id, timestamp, author, message])
+    return hashlib.sha256(chain_input.encode()).hexdigest()
+
+
+def build_chain(filename):
+    if not os.path.exists(HISTORY_FILE):
+        return False, "No DataVault project found."
+    with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+        history = json.load(f)
+    if filename not in history.get("files", {}):
+        return False, f"'{filename}' is not tracked."
+
+    versions        = history["files"][filename]["versions"]
+    prev_chain_hash = "GENESIS"
+    chain           = []
+
+    for v in versions:
+        chain_hash = compute_chain_hash(
+            v["hash"], prev_chain_hash, v["version_id"],
+            v["timestamp"], v.get("author", "unknown"), v["message"]
+        )
+        chain.append({
+            "version_id":      v["version_id"],
+            "file_hash":       v["hash"],
+            "prev_chain_hash": prev_chain_hash,
+            "chain_hash":      chain_hash,
+            "timestamp":       v["timestamp"],
+            "author":          v.get("author", "unknown"),
+            "message":         v["message"]
+        })
+        v["chain_hash"]      = chain_hash
+        v["prev_chain_hash"] = prev_chain_hash
+        prev_chain_hash      = chain_hash
+
+    with open(HISTORY_FILE, "w", encoding="utf-8") as f:
+        json.dump(history, f, indent=2)
+
+    chain_data = _load_chain()
+    chain_data["files"][filename] = chain
+    _save_chain(chain_data)
+    return True, chain
+
+
+def verify_chain(filename):
+    if not os.path.exists(HISTORY_FILE):
+        return False, "No DataVault project found."
+    with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+        history = json.load(f)
+    if filename not in history.get("files", {}):
+        return False, f"'{filename}' is not tracked."
+
+    versions = history["files"][filename]["versions"]
+    if not any("chain_hash" in v for v in versions):
+        return False, f"No chain data for '{filename}'.\nRun: python datavault.py chainbuild {filename}"
+
+    prev_chain_hash = "GENESIS"
+    results         = []
+    all_valid       = True
+
+    for v in versions:
+        stored = v.get("chain_hash")
+        if not stored:
+            results.append({"version_id": v["version_id"], "valid": False, "reason": "no chain hash — run chainbuild"})
+            all_valid = False
+            continue
+
+        expected = compute_chain_hash(
+            v["hash"], prev_chain_hash, v["version_id"],
+            v["timestamp"], v.get("author", "unknown"), v["message"]
+        )
+        valid = (expected == stored)
+        if not valid:
+            all_valid = False
+
+        results.append({
+            "version_id": v["version_id"],
+            "valid":      valid,
+            "stored":     stored[:24],
+            "expected":   expected[:24],
+            "prev":       prev_chain_hash[:24] if prev_chain_hash != "GENESIS" else "GENESIS",
+            "timestamp":  v["timestamp"][:19].replace("T", " "),
+            "message":    v["message"]
+        })
+        prev_chain_hash = stored
+
+    return all_valid, results
+
+
+def format_chain_verification(filename, results):
+    lines = [f"\nChain verification: '{filename}'\n" + "─"*55]
+    for r in results:
+        if r["valid"]:
+            lines.append(
+                f"\n  ✓ {r['version_id']}  |  {r.get('timestamp','')}\n"
+                f"    chain: {r.get('stored','?')}…\n"
+                f"    prev:  {r.get('prev','?')}…\n"
+                f"    \"{r.get('message','')}\""
+            )
+        else:
+            lines.append(
+                f"\n  ✗ {r['version_id']}  CHAIN BROKEN\n"
+                f"    stored:   {r.get('stored','?')}…\n"
+                f"    expected: {r.get('expected','?')}…\n"
+                f"    reason:   {r.get('reason','hash mismatch')}"
+            )
+    lines.append(f"\n{'─'*55}")
+    if all(r["valid"] for r in results):
+        lines.append(
+            f"  ✓ CHAIN INTACT — {len(results)} version(s) verified\n"
+            f"  Complete history is authentic and unmodified.\n"
+            f"  No versions were deleted, reordered, or tampered with."
+        )
+    else:
+        broken = [r["version_id"] for r in results if not r["valid"]]
+        lines.append(
+            f"  ✗ CHAIN BROKEN at: {', '.join(broken)}\n"
+            f"  History has been tampered with."
+        )
+    return "\n".join(lines)
+
+
+def display_chain(filename):
+    if not os.path.exists(HISTORY_FILE):
+        return False, "No DataVault project found."
+    with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+        history = json.load(f)
+    if filename not in history.get("files", {}):
+        return False, f"'{filename}' is not tracked."
+
+    versions = history["files"][filename]["versions"]
+    lines    = [f"\nHash chain: '{filename}'\n" + "─"*55]
+    lines.append("  (Each block's hash includes the previous block's hash)")
+    lines.append("  (Changing any block invalidates all blocks after it)\n")
+
+    for i, v in enumerate(versions):
+        chain_hash = v.get("chain_hash", "not computed")[:20]
+        file_hash  = v["hash"][:20]
+        prev_hash  = v.get("prev_chain_hash", "GENESIS")
+        if prev_hash != "GENESIS":
+            prev_hash = prev_hash[:20]
+        lines.append(f"  ┌─────────────────────────────────────┐")
+        lines.append(f"  │  {v['version_id']}  {v['timestamp'][:10]}           │")
+        lines.append(f"  │  file hash:  {file_hash}…  │")
+        lines.append(f"  │  prev hash:  {prev_hash}…  │")
+        lines.append(f"  │  chain hash: {chain_hash}…  │")
+        lines.append(f"  │  \"{v['message'][:30]}\"")
+        lines.append(f"  └──────────────────┬──────────────────┘")
+        if i < len(versions) - 1:
+            lines.append(f"                     │")
+            lines.append(f"                     ▼")
+
+    return True, "\n".join(lines)
+
+
+def _load_chain():
+    if os.path.exists(CHAIN_FILE):
+        with open(CHAIN_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return {"files": {}}
+
+
+def _save_chain(data):
+    with open(CHAIN_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)

dashboard.py

@@ -0,0 +1,211 @@
+import http.server
+import json
+import os
+import sys
+import webbrowser
+import threading
+import hashlib
+
+VAULT_DIR    = ".datavault"
+HISTORY_FILE = ".datavault/history.json"
+META_FILE    = ".datavault/meta.json"
+PORT         = 5000
+
+
+def build_dashboard_html():
+    if not os.path.exists(HISTORY_FILE):
+        return _error_page("No DataVault project found. Run 'python datavault.py init <name>' first.")
+
+    with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+        history = json.load(f)
+    with open(META_FILE, "r", encoding="utf-8") as f:
+        meta = json.load(f)
+
+    proj_name  = meta.get("project_name", "DataVault Project")
+    created_by = meta.get("created_by", "unknown")
+    file_cards = ""
+
+    for filename, data in history["files"].items():
+        versions  = data["versions"]
+        latest    = versions[-1]
+        if os.path.exists(filename):
+            status_html = '<span class="status ok">✓ up to date</span>' if _hash_file(filename) == latest["hash"] else '<span class="status warn">⚠ modified — run commit</span>'
+        else:
+            status_html = '<span class="status err">✗ file missing</span>'
+
+        timeline_items = ""
+        for i, v in enumerate(reversed(versions)):
+            ts       = v["timestamp"][:19].replace("T", " ")
+            tags     = v.get("tags", [])
+            tag_html = "".join(f'<span class="tag">{t["message"]}</span>' for t in tags)
+            is_latest = (i == 0)
+            timeline_items += f"""
+            <div class="version-item {'latest' if is_latest else ''}">
+              <div class="version-dot"></div>
+              <div class="version-body">
+                <div class="version-top">
+                  <span class="vid">{v["version_id"]}</span>
+                  <span class="vmsg">{v["message"]}</span>
+                  {'<span class="latest-badge">latest</span>' if is_latest else ''}
+                </div>
+                <div class="version-meta">{ts} · {v.get("author","?")} · {_fmt_size(v["size_bytes"])}</div>
+                <div class="version-hash">{v["hash"][:32]}…</div>
+                {f'<div class="tags">{tag_html}</div>' if tags else ''}
+              </div>
+            </div>"""
+
+        file_cards += f"""
+        <div class="file-card">
+          <div class="file-card-header">
+            <div>
+              <div class="filename">{filename}</div>
+              <div class="file-meta">{len(versions)} version(s) · last: {latest["timestamp"][:10]}</div>
+            </div>
+            {status_html}
+          </div>
+          <div class="timeline">{timeline_items}</div>
+        </div>"""
+
+    if not file_cards:
+        file_cards = '<div class="empty">No files tracked yet. Use <code>datavault add &lt;file&gt; "&lt;message&gt;"</code> to start.</div>'
+
+    total_versions = sum(len(d["versions"]) for d in history["files"].values())
+    total_tags     = sum(len(v.get("tags",[])) for d in history["files"].values() for v in d["versions"])
+
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DataVault — {proj_name}</title>
+<style>
+  *,*::before,*::after{{box-sizing:border-box;margin:0;padding:0}}
+  body{{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;background:#f7f7f5;color:#1a1a1a;min-height:100vh}}
+  .topbar{{background:#1a1a1a;color:#fff;padding:0 32px;height:56px;display:flex;align-items:center;justify-content:space-between;position:sticky;top:0;z-index:10}}
+  .topbar-left{{display:flex;align-items:center;gap:12px}}
+  .logo{{font-size:15px;font-weight:600;letter-spacing:-.3px}}
+  .proj{{font-size:13px;color:#999}}
+  .topbar-right{{font-size:12px;color:#666}}
+  .stats-bar{{background:#fff;border-bottom:1px solid #e8e8e8;padding:16px 32px;display:flex;gap:32px}}
+  .stat{{display:flex;flex-direction:column;gap:2px}}
+  .stat-val{{font-size:20px;font-weight:600;color:#1a1a1a}}
+  .stat-lbl{{font-size:11px;color:#888;text-transform:uppercase;letter-spacing:.5px}}
+  .main{{max-width:860px;margin:32px auto;padding:0 24px}}
+  .section-title{{font-size:13px;font-weight:500;color:#888;text-transform:uppercase;letter-spacing:.5px;margin-bottom:16px}}
+  .file-card{{background:#fff;border:1px solid #e8e8e8;border-radius:10px;margin-bottom:20px;overflow:hidden}}
+  .file-card-header{{padding:16px 20px;border-bottom:1px solid #f0f0f0;display:flex;justify-content:space-between;align-items:flex-start}}
+  .filename{{font-size:15px;font-weight:600;margin-bottom:3px}}
+  .file-meta{{font-size:12px;color:#888}}
+  .status{{font-size:12px;padding:4px 10px;border-radius:20px;font-weight:500}}
+  .status.ok{{background:#e8f4e8;color:#2a6a2a}}
+  .status.warn{{background:#fff3e0;color:#8a4a00}}
+  .status.err{{background:#fdecea;color:#8a1a1a}}
+  .timeline{{padding:12px 20px 4px}}
+  .version-item{{display:flex;gap:12px;padding:10px 0;border-bottom:1px solid #f5f5f5}}
+  .version-item:last-child{{border-bottom:none}}
+  .version-dot{{width:10px;height:10px;border-radius:50%;background:#d0d0d0;margin-top:5px;flex-shrink:0}}
+  .version-item.latest .version-dot{{background:#2a6a2a}}
+  .version-body{{flex:1;min-width:0}}
+  .version-top{{display:flex;align-items:center;gap:8px;margin-bottom:3px;flex-wrap:wrap}}
+  .vid{{font-family:'Courier New',monospace;font-size:12px;font-weight:700;background:#f0f0f0;padding:1px 6px;border-radius:4px;color:#444}}
+  .vmsg{{font-size:13px;color:#1a1a1a}}
+  .latest-badge{{font-size:10px;background:#e8f4e8;color:#2a6a2a;padding:2px 7px;border-radius:10px;font-weight:500}}
+  .version-meta{{font-size:11px;color:#999;margin-bottom:3px}}
+  .version-hash{{font-family:'Courier New',monospace;font-size:10px;color:#bbb}}
+  .tags{{margin-top:5px}}
+  .tag{{display:inline-block;background:#e8f0fe;color:#1a56a8;padding:2px 8px;border-radius:10px;font-size:11px;margin:2px 3px 2px 0;border:1px solid #c2d4f5}}
+  .empty{{padding:32px;text-align:center;color:#999;font-size:14px}}
+  .empty code{{background:#f0f0f0;padding:2px 6px;border-radius:4px;font-size:13px;color:#444}}
+  .commands{{background:#1a1a1a;border-radius:10px;padding:20px 24px;margin-top:32px}}
+  .commands-title{{color:#888;font-size:11px;text-transform:uppercase;letter-spacing:.5px;margin-bottom:12px}}
+  .cmd-grid{{display:grid;grid-template-columns:1fr 1fr;gap:6px}}
+  .cmd{{font-family:'Courier New',monospace;font-size:12px;color:#ccc;padding:4px 0}}
+  .cmd span{{color:#7dd3a8}}
+  .refresh-note{{text-align:center;color:#aaa;font-size:12px;margin-top:24px;margin-bottom:8px}}
+  a.refresh-btn{{display:inline-block;color:#555;text-decoration:none;border:1px solid #ddd;padding:5px 14px;border-radius:6px;font-size:12px;margin-left:8px}}
+  a.refresh-btn:hover{{background:#f0f0f0}}
+</style>
+</head>
+<body>
+<div class="topbar">
+  <div class="topbar-left"><span class="logo">DataVault</span><span class="proj">/ {proj_name}</span></div>
+  <div class="topbar-right">by {created_by}</div>
+</div>
+<div class="stats-bar">
+  <div class="stat"><span class="stat-val">{len(history["files"])}</span><span class="stat-lbl">Files tracked</span></div>
+  <div class="stat"><span class="stat-val">{total_versions}</span><span class="stat-lbl">Total versions</span></div>
+  <div class="stat"><span class="stat-val">{total_tags}</span><span class="stat-lbl">Tags</span></div>
+  <div class="stat"><span class="stat-val">SHA-256</span><span class="stat-lbl">Hash algorithm</span></div>
+</div>
+<div class="main">
+  <div class="section-title">Tracked files</div>
+  {file_cards}
+  <div class="commands">
+    <div class="commands-title">Quick reference</div>
+    <div class="cmd-grid">
+      <div class="cmd"><span>add</span> &lt;file&gt; "message"</div>
+      <div class="cmd"><span>commit</span> &lt;file&gt; "message"</div>
+      <div class="cmd"><span>verify</span> &lt;file&gt;</div>
+      <div class="cmd"><span>log</span> &lt;file&gt;</div>
+      <div class="cmd"><span>tag</span> &lt;file&gt; v2 "label"</div>
+      <div class="cmd"><span>diff</span> &lt;file&gt; v1 v2</div>
+      <div class="cmd"><span>checkout</span> &lt;file&gt; v1</div>
+      <div class="cmd"><span>export</span></div>
+    </div>
+  </div>
+  <p class="refresh-note">Data updates when you refresh. <a class="refresh-btn" href="/">↻ Refresh</a></p>
+</div>
+</body>
+</html>"""
+
+
+def _error_page(message):
+    return f'<!DOCTYPE html><html><body style="font-family:sans-serif;padding:40px;color:#666"><h2 style="color:#1a1a1a">DataVault Dashboard</h2><p style="margin-top:12px">{message}</p></body></html>'
+
+
+def _hash_file(filepath):
+    sha256 = hashlib.sha256()
+    with open(filepath, "rb") as f:
+        while chunk := f.read(65536):
+            sha256.update(chunk)
+    return sha256.hexdigest()
+
+
+def _fmt_size(b):
+    if b < 1024: return f"{b} B"
+    if b < 1024*1024: return f"{b/1024:.1f} KB"
+    return f"{b/1024/1024:.1f} MB"
+
+
+class DashboardHandler(http.server.BaseHTTPRequestHandler):
+    def do_GET(self):
+        html = build_dashboard_html().encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(html)))
+        self.end_headers()
+        self.wfile.write(html)
+
+    def log_message(self, format, *args):
+        pass
+
+
+def main():
+    if not os.path.exists(VAULT_DIR):
+        print("No DataVault project found. Run: python datavault.py init <name>")
+        sys.exit(1)
+
+    server = http.server.HTTPServer(("localhost", PORT), DashboardHandler)
+    print(f"\nDataVault Dashboard → http://localhost:{PORT}")
+    print("Refresh browser after any commit. Ctrl+C to stop.\n")
+
+    threading.Thread(target=lambda: (__import__('time').sleep(0.5), __import__('webbrowser').open(f"http://localhost:{PORT}")), daemon=True).start()
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nDashboard stopped.")
+
+
+if __name__ == "__main__":
+    main()

datavault.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+import sys
+import os
+
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+
+import vault_core as core
+import row_tracker
+import chain as chain_module
+import signing
+
+GREEN  = "\033[92m"
+RED    = "\033[91m"
+BLUE   = "\033[94m"
+BOLD   = "\033[1m"
+RESET  = "\033[0m"
+
+def ok(message):  print(f"{GREEN}✓{RESET} {message}")
+def err(message): print(f"{RED}✗{RESET} {message}")
+def info(message):print(f"{BLUE}ℹ{RESET} {message}")
+
+HELP = f"""
+{BOLD}DataVault{RESET} — version control for datasets
+
+{BOLD}COMMANDS:{RESET}
+  {GREEN}init{RESET} <name>                        Start a new project
+  {GREEN}add{RESET} <file> "<message>"             Start tracking a file
+  {GREEN}commit{RESET} <file> "<message>"          Save a new version
+  {GREEN}log{RESET} <file>                         Show version history
+  {GREEN}status{RESET}                             Show all tracked files
+  {GREEN}verify{RESET} <file>                      Check for tampering
+  {GREEN}checkout{RESET} <file> <v>                Restore a version
+  {GREEN}diff{RESET} <file> <v1> <v2>              Show text diff
+  {GREEN}tag{RESET} <file> <v> "<msg>"             Label a version
+  {GREEN}tags{RESET} <file>                        List all tags
+  {GREEN}export{RESET}                             Export HTML/PDF report
+  {GREEN}dashboard{RESET}                          Open web dashboard
+
+{BOLD}ROW-LEVEL (CSV):{RESET}
+  {GREEN}rowlog{RESET} <file>                      Row change statistics
+  {GREEN}rowdiff{RESET} <file> <v1> <v2>           Which rows changed
+  {GREEN}rowhistory{RESET} <file> <col> <val>       History of one row
+
+{BOLD}HASH CHAIN:{RESET}
+  {GREEN}chain{RESET} <file>                       Verify chain
+  {GREEN}chainshow{RESET} <file>                   Display chain visually
+  {GREEN}chainbuild{RESET} <file>                  Build/rebuild chain
+
+{BOLD}SIGNATURES:{RESET}
+  {GREEN}sign{RESET} <file> <v> <name> [role]      Sign a version
+  {GREEN}signatures{RESET} <file> [version]         List or verify signatures
+  {GREEN}approve{RESET} <file> <version>            Check approval status
+  {GREEN}help{RESET}                               Show this message
+"""
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] == "help":
+        print(HELP)
+        return
+
+    command = args[0].lower()
+
+    if command == "init":
+        if len(args) < 2:
+            err("Usage: python datavault.py init <project_name>"); return
+        success, message = core.init_project(args[1])
+        ok(message) if success else err(message)
+
+    elif command == "add":
+        if len(args) < 3:
+            err('Usage: python datavault.py add <file> "<message>"'); return
+        filepath, message = args[1], " ".join(args[2:])
+        success, result = core.add_file(filepath, message)
+        ok(result) if success else err(result)
+        if success:
+            if row_tracker.snapshot_on_commit(filepath, "v1"):
+                info("Row-level snapshot created")
+            chain_module.build_chain(os.path.basename(filepath))
+            info("Hash chain updated")
+
+    elif command == "commit":
+        if len(args) < 3:
+            err('Usage: python datavault.py commit <file> "<message>"'); return
+        filepath, message = args[1], " ".join(args[2:])
+        success, result = core.commit_file(filepath, message)
+        ok(result) if success else err(result)
+        if success:
+            import json
+            with open(core.HISTORY_FILE) as f:
+                hist = json.load(f)
+            fname   = os.path.basename(filepath)
+            new_vid = hist["files"][fname]["versions"][-1]["version_id"]
+            if row_tracker.snapshot_on_commit(filepath, new_vid):
+                info("Row-level snapshot created")
+            chain_module.build_chain(fname)
+            info("Hash chain updated")
+
+    elif command == "log":
+        if len(args) < 2:
+            err("Usage: python datavault.py log <file>"); return
+        success, result = core.get_log(args[1])
+        print(result) if success else err(result)
+
+    elif command == "status":
+        success, result = core.list_files()
+        print(result) if success else err(result)
+
+    elif command == "verify":
+        if len(args) < 2:
+            err("Usage: python datavault.py verify <file>"); return
+        success, result = core.verify_file(args[1])
+        print(result) if success else err(result)
+
+    elif command == "checkout":
+        if len(args) < 3:
+            err("Usage: python datavault.py checkout <file> <version>"); return
+        success, result = core.checkout_version(args[1], args[2])
+        ok(result) if success else err(result)
+
+    elif command == "diff":
+        if len(args) < 4:
+            err("Usage: python datavault.py diff <file> <v1> <v2>"); return
+        success, result = core.diff_versions(args[1], args[2], args[3])
+        print(result) if success else err(result)
+
+    elif command == "rowlog":
+        if len(args) < 2:
+            err("Usage: python datavault.py rowlog <file>"); return
+        success, result = row_tracker.row_stats(args[1])
+        print(result) if success else err(result)
+
+    elif command == "rowdiff":
+        if len(args) < 4:
+            err("Usage: python datavault.py rowdiff <file> <v1> <v2>"); return
+        success, result = row_tracker.row_diff(args[1], args[2], args[3])
+        print(result) if success else err(result)
+
+    elif command == "rowhistory":
+        if len(args) < 4:
+            err("Usage: python datavault.py rowhistory <file> <column> <value>"); return
+        success, result = row_tracker.row_history(args[1], args[2], args[3])
+        print(result) if success else err(result)
+
+    elif command == "chain":
+        if len(args) < 2:
+            err("Usage: python datavault.py chain <file>"); return
+        filename = os.path.basename(args[1])
+        valid, results = chain_module.verify_chain(filename)
+        print(chain_module.format_chain_verification(filename, results)) if isinstance(results, list) else err(results)
+
+    elif command == "chainshow":
+        if len(args) < 2:
+            err("Usage: python datavault.py chainshow <file>"); return
+        success, result = chain_module.display_chain(os.path.basename(args[1]))
+        print(result) if success else err(result)
+
+    elif command == "chainbuild":
+        if len(args) < 2:
+            err("Usage: python datavault.py chainbuild <file>"); return
+        filename = os.path.basename(args[1])
+        success, result = chain_module.build_chain(filename)
+        ok(f"Chain built for '{filename}' ({len(result)} version(s))") if success else err(result)
+
+    elif command == "sign":
+        if len(args) < 4:
+            err("Usage: python datavault.py sign <file> <version> <signer> [role]"); return
+        role = args[4] if len(args) > 4 else "reviewer"
+        success, result = signing.sign_version(args[1], args[2], args[3], role)
+        ok(result) if success else err(result)
+
+    elif command == "signatures":
+        if len(args) < 2:
+            err("Usage: python datavault.py signatures <file> [version]"); return
+        if len(args) >= 3:
+            success, result = signing.verify_signatures(args[1], args[2])
+        else:
+            success, result = signing.list_all_signatures(args[1])
+        print(result) if success else err(result)
+
+    elif command == "approve":
+        if len(args) < 3:
+            err("Usage: python datavault.py approve <file> <version>"); return
+        _, result = signing.approval_status(args[1], args[2])
+        print(result)
+
+    elif command == "tag":
+        if len(args) < 4:
+            err('Usage: python datavault.py tag <file> <version> "<message>"'); return
+        success, result = core.tag_version(args[1], args[2], " ".join(args[3:]))
+        ok(result) if success else err(result)
+
+    elif command == "tags":
+        if len(args) < 2:
+            err("Usage: python datavault.py tags <file>"); return
+        success, result = core.list_tags(args[1])
+        print(result) if success else err(result)
+
+    elif command == "export":
+        output = args[1] if len(args) > 1 else "datavault_report.pdf"
+        success, result = core.export_pdf(output)
+        ok(result) if success else err(result)
+
+    elif command == "dashboard":
+        import dashboard as db_module
+        db_module.main()
+
+    else:
+        err(f"Unknown command: '{command}'")
+        info("Run 'python datavault.py help' to see all commands")
+
+if __name__ == "__main__":
+    main()