vichar 0.1.0__py3-none-any.whl

vichar-0.1.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: vichar
+Version: 0.1.0
+Summary: Versioned Intent and Context History for Agentic Reasoning — capture the why behind AI agent decisions
+Author-email: Shivranjan Kolvankar <shivranjankolvankar@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Shivranjan Kolvankar
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/shivranjankolvankar/vichar
+Project-URL: Repository, https://github.com/shivranjankolvankar/vichar
+Keywords: ai,agent,reasoning,decision,claude,cursor,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# VICHAR — विचार
+
+**Versioned Intent and Context History for Agentic Reasoning**
+
+VICHAR captures *why* AI agents make decisions — not just what they do.
+Every decision, open question, and task is recorded so the next session
+(or a different agent) starts with full context instead of zero.
+
+---
+
+## Install
+
+```bash
+pip install vichar
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/shivranjankolvankar/vichar
+cd vichar
+pip install -e .
+```
+
+---
+
+## Quick start
+
+```bash
+# Initialise in your project
+cd my-project
+vichar init
+
+# Agents capture reasoning as they work
+vichar capture "Use FastAPI over Flask" \
+  --type decision \
+  --author claude-code \
+  --body "Flask lacks async support. FastAPI gives us OpenAPI docs for free."
+
+# At session start — read prior context
+vichar log
+
+# Confirm an entry (human ratification)
+vichar ratify abc12345
+
+# One-line project summary
+vichar status
+```
+
+---
+
+## Core concept: the trust gradient
+
+| Status | Meaning |
+|--------|---------|
+| `proposed` | Agent-written, unreviewed |
+| `ratified` | Human-confirmed |
+| `closed` | No longer relevant |
+
+Agents write freely. Humans decide what to trust.
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `vichar init` | Stamp project, write agent files, inject into CLAUDE.md + .cursor/rules |
+| `vichar capture "<text>"` | Capture a decision, thread, or task |
+| `vichar ratify <id>` | Mark an entry as human-confirmed |
+| `vichar close <id>` | Close an entry |
+| `vichar log` | Show open entries (rich table) |
+| `vichar status` | One-line project summary (add `--json` for machine output) |
+| `vichar migrate` | Upgrade pre-schema entries to schema v1 |
+| `vichar uninit` | Remove VICHAR injection from CLAUDE.md + .cursor/rules |
+| `vichar-server` | Start HTTP server on port 7474 (fallback for shell-less agents) |
+
+---
+
+## HTTP server (agent fallback)
+
+When an agent cannot run shell commands, it can POST over HTTP instead:
+
+```bash
+vichar-server [--port 7474] [--host 127.0.0.1]
+```
+
+```python
+import urllib.request, json
+
+def vichar(title, type="decision", body="", author="agent"):
+    data = json.dumps({"title": title, "type": type,
+                       "body": body, "author": author}).encode()
+    req = urllib.request.Request(
+        "http://localhost:7474/capture", data=data,
+        headers={"Content-Type": "application/json"}, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=2) as r:
+            return json.loads(r.read())
+    except Exception:
+        return None  # never block on VICHAR
+```
+
+Server endpoints: `GET /`  `GET /status`  `GET /log`  `POST /capture`  `POST /ratify`  `POST /close`
+
+---
+
+## Agent integration
+
+`vichar init` writes instruction files and injects them automatically:
+
+- **Claude Code** (`CLAUDE.md`): injects `@.vichar/CLAUDE.md` import line  
+- **Cursor** (`.cursor/rules`): inlines the full instruction block  
+- Both injections are non-destructive (VICHAR START/END markers, idempotent)
+
+The agent files tell Claude / Cursor *when* to capture, *how* to capture, and the HTTP fallback snippet.
+
+---
+
+## What gets stored
+
+Each entry in `.vichar/entries.json` has:
+
+| Field | Description |
+|-------|-------------|
+| `id` | 8-char hex identifier |
+| `type` | `decision` / `thread` / `task` |
+| `status` | `proposed` / `ratified` / `closed` |
+| `title` | One-line summary |
+| `body` | Extended reasoning (markdown) |
+| `author` | `claude-code` / `cursor` / `human` / `agent` |
+| `schema` | `"1"` (schema version) |
+
+---
+
+## Zero dependencies
+
+VICHAR is pure Python stdlib — no `rich`, no `colorama`, no `click`.
+It works in any Python 3.8+ environment without `pip install` overhead.
+
+---
+
+## License
+
+MIT

vichar-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+vichar.py,sha256=63yVsk5zoOsKnCvYzBKhj6_Prak4hbVbR1nsYp4YYuw,28854
+vichar_server.py,sha256=raqFNv_AHWXeFzvbH-PbhjI04qrogByoOp6e8QaRM6k,9936
+vichar-0.1.0.dist-info/licenses/LICENSE,sha256=DykkiN_FSW6Pw-cclr4Ulb4epWjS8RdWfMD1bBWYqRA,1077
+vichar-0.1.0.dist-info/METADATA,sha256=46d7IHp8ZgkjbJq0kqdC9bcRox3fBhgzIy5qmhChgLA,6267
+vichar-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+vichar-0.1.0.dist-info/entry_points.txt,sha256=3vPKuyd6hPOAj5QiDe7qA9p_GcIxDqkRJccZvyxT6hQ,74
+vichar-0.1.0.dist-info/top_level.txt,sha256=HvgC3-hFLFDTgqg3SbO7ZbZx9auVB1mfbeM24GJQIEc,21
+vichar-0.1.0.dist-info/RECORD,,

vichar-0.1.0.dist-info/WHEEL

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

vichar-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+vichar = vichar:main
+vichar-server = vichar_server:main

vichar-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Shivranjan Kolvankar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vichar-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+vichar
+vichar_server

vichar.py

@@ -0,0 +1,772 @@
+#!/usr/bin/env python3
+"""
+VICHAR - Versioned Intent and Context History for Agentic Reasoning
+vichar: The thinking that leads to decisions.
+
+Commands:
+  vichar init              Stamp project, write agent files, inject into CLAUDE.md + .cursor/rules
+  vichar capture "<text>"  Capture a decision, thread, or task
+  vichar ratify <id>       Mark an entry as human-confirmed
+  vichar close <id>        Close an entry
+  vichar log               Show open entries (rich table)
+  vichar status            One-line project summary
+  vichar migrate           Upgrade pre-schema entries to schema v1
+  vichar uninit            Remove VICHAR injection from CLAUDE.md + .cursor/rules
+  vichar --version         Print version
+"""
+
+import argparse
+import json
+import os
+import platform
+import sys
+import uuid
+from datetime import datetime, timezone
+
+VERSION = "0.1.0"
+LOCK_TIMEOUT = 2.0
+
+# ---------------------------------------------------------------------------
+# ANSI colours (disabled in pipes, CI, and when NO_COLOR is set)
+# ---------------------------------------------------------------------------
+
+def _ansi_enabled():
+    if os.environ.get("NO_COLOR"):
+        return False
+    if not sys.stdout.isatty():
+        return False
+    if platform.system() == "Windows":
+        os.system("")  # enable VT100 on Windows 10+
+    return True
+
+_ANSI = _ansi_enabled()
+GREEN  = "\033[92m" if _ANSI else ""
+YELLOW = "\033[93m" if _ANSI else ""
+RED    = "\033[91m" if _ANSI else ""
+CYAN   = "\033[96m" if _ANSI else ""
+BOLD   = "\033[1m"  if _ANSI else ""
+DIM    = "\033[2m"  if _ANSI else ""
+RESET  = "\033[0m"  if _ANSI else ""
+
+# ---------------------------------------------------------------------------
+# Embedded agent instruction templates
+# ---------------------------------------------------------------------------
+
+CLAUDE_MD_TEMPLATE = """\
+# VICHAR - Agent Instructions for Claude Code
+
+This project uses VICHAR to capture reasoning as it happens.
+VICHAR stores decisions, open questions, and tasks so the next
+session starts with full context instead of zero.
+
+## When to capture
+
+Call vichar capture at these moments only:
+
+| Moment | Type | Example |
+|--------|------|---------|
+| Choose between two approaches | decision | chose FastAPI over Flask |
+| Hit a question you cannot resolve | thread | unclear if schema will change |
+| Start significant work | task | refactoring parameter extraction |
+| Make an assumption that could break | decision | assuming schema is stable |
+| Discover something unexpected | thread | found a second 401 error path |
+
+Do NOT capture every tool call or file read. Capture the why and the
+unresolved, not the what.
+
+## How to capture - CLI (primary)
+
+  vichar capture "Use instructor over raw JSON parsing" --type decision --author claude-code --body "Manual parsing breaks on schema drift."
+  vichar capture "Should retry logic live in pipeline or caller?" --type thread --author claude-code --body "Retrying in pipeline hides errors."
+  vichar capture "Refactor parameter extraction" --type task --author claude-code
+
+If vichar is not found use the full path:
+  python "E:\\GenAI Learning\\VICHAR\\VICHAR\\vichar.py" capture "..." --type decision --author claude-code
+
+Always include --body when the decision has trade-offs.
+
+## How to capture - HTTP fallback
+
+  import urllib.request, json
+  def vichar(title, type="decision", body="", author="claude-code"):
+      data = json.dumps({"title": title, "type": type, "body": body, "author": author}).encode()
+      req = urllib.request.Request("http://localhost:7474/capture", data=data,
+            headers={"Content-Type": "application/json"}, method="POST")
+      try:
+          with urllib.request.urlopen(req, timeout=2) as r: return json.loads(r.read())
+      except Exception: return None
+
+## Rules
+
+- Never ask "should I capture this?" - just capture it.
+- Capture as you go, not at session end. Abrupt closes lose session-end writes.
+- Never block on VICHAR. If CLI and HTTP both fail, continue working.
+
+## Session start
+
+  vichar log
+  (or: python "E:\\GenAI Learning\\VICHAR\\VICHAR\\vichar.py" log)
+"""
+
+CURSOR_RULES_TEMPLATE = """\
+# VICHAR - Agent Instructions for Cursor
+
+Run vichar log at the start of every session to load prior context.
+
+## When to capture
+
+- Choosing between two approaches -> type: decision
+- Hitting an unresolved question -> type: thread
+- Starting significant work -> type: task
+- Making an assumption that could break later -> type: decision
+
+## CLI (primary)
+
+  vichar capture "<title>" --type decision|thread|task --author cursor --body "<reasoning>"
+
+If vichar is not found:
+  python "E:\\GenAI Learning\\VICHAR\\VICHAR\\vichar.py" capture "<title>" --type decision|thread|task --author cursor
+
+## HTTP fallback
+
+  POST http://localhost:7474/capture
+  Content-Type: application/json
+  {"title": "...", "type": "decision", "body": "...", "author": "cursor"}
+
+## Rules
+
+1. Always include --body when there are trade-offs. The reasoning IS the value.
+2. Capture as you go - not at session end.
+3. Never block on VICHAR. If both fail, continue silently.
+4. Do not ask the user whether to capture - just capture and continue.
+"""
+
+SCHEMA_MD_TEMPLATE = """\
+# VICHAR Schema
+
+## Entry (schema v1)
+
+| Field       | Type            | Required | Description                        |
+|-------------|-----------------|----------|------------------------------------|
+| id          | string (8 hex)  | yes      | Unique entry identifier            |
+| project_id  | string          | yes      | From .vichar/project.json          |
+| schema      | string ("1")    | yes      | Schema version                     |
+| type        | enum            | yes      | decision, thread, task             |
+| status      | enum            | yes      | proposed, ratified, open, closed   |
+| title       | string          | yes      | One-line summary                   |
+| body        | string          | no       | Extended reasoning (markdown)      |
+| author      | string          | yes      | claude-code, cursor, human, agent  |
+| created_at  | ISO 8601        | yes      | UTC timestamp                      |
+| updated_at  | ISO 8601        | yes      | Updated on ratify/close            |
+| ratified_by | string or null  | no       | Set on ratify                      |
+| ratified_at | ISO 8601 or null| no       | Set on ratify                      |
+
+## Schema v0 (pre-release)
+
+Entries without the "schema" key are implicitly v0.
+Run: vichar migrate  to upgrade all v0 entries to v1.
+"""
+
+VICHAR_MARKER_START = "# --- VICHAR START ---"
+VICHAR_MARKER_END   = "# --- VICHAR END ---"
+
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+
+def find_root(start=None):
+    current = os.path.abspath(start or os.getcwd())
+    while True:
+        if os.path.exists(os.path.join(current, ".vichar", "project.json")):
+            return current
+        parent = os.path.dirname(current)
+        if parent == current:
+            return None
+        current = parent
+
+def vdir(root): return os.path.join(root, ".vichar")
+def pfile(root): return os.path.join(vdir(root), "project.json")
+def efile(root): return os.path.join(vdir(root), "entries.json")
+
+# ---------------------------------------------------------------------------
+# Cross-platform file locking
+# ---------------------------------------------------------------------------
+
+def _acquire_lock(lock_path, timeout=LOCK_TIMEOUT):
+    import time
+    lock_file = open(lock_path, "w")
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            if platform.system() == "Windows":
+                import msvcrt
+                msvcrt.locking(lock_file.fileno(), msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            return lock_file
+        except (IOError, OSError):
+            time.sleep(0.05)
+    lock_file.close()
+    return None  # timed out — caller proceeds without lock
+
+def _release_lock(lock_file):
+    if lock_file is None:
+        return
+    try:
+        if platform.system() == "Windows":
+            import msvcrt
+            msvcrt.locking(lock_file.fileno(), msvcrt.LK_UNLCK, 1)
+        else:
+            import fcntl
+            fcntl.flock(lock_file, fcntl.LOCK_UN)
+    except Exception:
+        pass
+    finally:
+        lock_file.close()
+
+# ---------------------------------------------------------------------------
+# Storage (atomic writes)
+# ---------------------------------------------------------------------------
+
+def load_project(root):
+    with open(pfile(root)) as f:
+        return json.load(f)
+
+def load_entries(root):
+    path = efile(root)
+    if not os.path.exists(path):
+        return []
+    with open(path) as f:
+        return json.load(f)
+
+def save_entries(root, entries):
+    """Atomic write: tmp file + os.replace."""
+    tmp = efile(root) + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(entries, f, indent=2)
+    os.replace(tmp, efile(root))
+
+def _clean_stale_tmp(root):
+    tmp = efile(root) + ".tmp"
+    if os.path.exists(tmp):
+        os.remove(tmp)
+        print(DIM + "Note: cleaned up stale entries.tmp from a previous crashed write." + RESET)
+
+def now_iso():
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+def short_id():
+    return str(uuid.uuid4())[:8]
+
+# ---------------------------------------------------------------------------
+# Core operations (shared with vichar_server.py)
+# ---------------------------------------------------------------------------
+
+def op_capture(root, title, etype="decision", body="", author="human"):
+    lock_path = os.path.join(vdir(root), "entries.lock")
+    lf = _acquire_lock(lock_path)
+    try:
+        proj = load_project(root)
+        entries = load_entries(root)
+        entry = {
+            "id": short_id(), "project_id": proj["id"], "schema": "1",
+            "type": etype, "status": "proposed", "title": title,
+            "body": body, "author": author,
+            "created_at": now_iso(), "updated_at": now_iso(),
+            "ratified_by": None, "ratified_at": None,
+        }
+        entries.append(entry)
+        save_entries(root, entries)
+        return entry
+    finally:
+        _release_lock(lf)
+
+def op_ratify(root, entry_id, by="human"):
+    lock_path = os.path.join(vdir(root), "entries.lock")
+    lf = _acquire_lock(lock_path)
+    try:
+        entries = load_entries(root)
+        t = next((e for e in entries if e["id"] == entry_id), None)
+        if not t:
+            return None, "not found: " + entry_id
+        if t["status"] == "ratified":
+            return t, "already ratified"
+        t["status"] = "ratified"; t["ratified_by"] = by
+        t["ratified_at"] = now_iso(); t["updated_at"] = now_iso()
+        save_entries(root, entries)
+        return t, None
+    finally:
+        _release_lock(lf)
+
+def op_close(root, entry_id):
+    lock_path = os.path.join(vdir(root), "entries.lock")
+    lf = _acquire_lock(lock_path)
+    try:
+        entries = load_entries(root)
+        t = next((e for e in entries if e["id"] == entry_id), None)
+        if not t:
+            return None, "not found: " + entry_id
+        t["status"] = "closed"; t["updated_at"] = now_iso()
+        save_entries(root, entries)
+        return t, None
+    finally:
+        _release_lock(lf)
+
+def op_log(root, etype=None, include_closed=False):
+    entries = load_entries(root)
+    if etype:
+        entries = [e for e in entries if e["type"] == etype]
+    if not include_closed:
+        entries = [e for e in entries if e["status"] != "closed"]
+    return entries
+
+
+# ---------------------------------------------------------------------------
+# Rendering
+# ---------------------------------------------------------------------------
+
+def _tw():
+    try:
+        return os.get_terminal_size().columns
+    except Exception:
+        return 80
+
+def _box(title, rows):
+    w = max(46, max((len(r[0]) + len(r[1]) + 4) for r in rows) + 2)
+    line = lambda c: "+" + c * (w - 2) + "+"
+    cell = lambda k, v: "| " + CYAN + BOLD + k + RESET + "  " + v + " " * (w - 4 - len(k) - len(v)) + "|"
+    sep_row = lambda: "+" + "-" * (w - 2) + "+"
+    out = [line("="), "| " + BOLD + title.center(w - 4) + RESET + " |", sep_row()]
+    last_group = None
+    for k, v, group in rows:
+        if group != last_group and last_group is not None:
+            out.append(sep_row())
+        last_group = group
+        out.append(cell(k, v))
+    out.append(line("="))
+    return "\n".join(out)
+
+def render_log(entries, proj):
+    tw = _tw()
+    id_w, type_w = 10, 10
+    title_w = tw - id_w - type_w - 7
+    divider = "+" + "-" * (id_w) + "+" + "-" * (type_w) + "+" + "-" * (title_w + 2) + "+"
+    header  = "| " + "st".ljust(id_w - 2) + " | " + "type".ljust(type_w - 2) + " | " + "title".ljust(title_w) + " |"
+    name_line = BOLD + "VICHAR" + RESET + "  " + CYAN + proj["name"] + RESET + "  (" + DIM + proj["id"] + RESET + ")"
+    counts = str(len(entries)) + " entries"
+    proposed = [e for e in entries if e["status"] == "proposed"]
+    if proposed:
+        counts += "  " + YELLOW + str(len(proposed)) + " proposed" + RESET
+    lines = ["", name_line + "  " + counts, divider, header, divider]
+
+    ICONS = {"ratified": GREEN + "V" + RESET, "proposed": YELLOW + "?" + RESET,
+             "open": RED + "o" + RESET, "closed": DIM + "X" + RESET}
+
+    if not entries:
+        lines.append('| ' + ('No entries yet. Run: vichar capture "<thought>"').ljust(tw - 4) + ' |')
+    else:
+        for e in entries:
+            icon = ICONS.get(e["status"], ".")
+            etype = e["type"].ljust(type_w - 2)
+            etitle = e["title"][:title_w].ljust(title_w)
+            lines.append("| " + icon + " " * (id_w - 2) + " | " + etype + " | " + etitle + " |")
+            if e.get("body"):
+                body_preview = DIM + e["body"][:tw - 6] + RESET
+                lines.append("|   " + body_preview + " " * max(0, tw - 5 - len(e["body"][:tw-6])) + "|")
+    lines.append(divider)
+    if proposed:
+        lines.append(DIM + "  " + str(len(proposed)) + " pending -- run: vichar ratify <id>" + RESET)
+    v0 = [e for e in load_entries(find_root() or ".") if not e.get("schema")]
+    if v0:
+        lines.append(DIM + "  Note: " + str(len(v0)) + " entries predate schema v1. Run: vichar migrate" + RESET)
+    lines.append("")
+    return "\n".join(lines)
+
+def _time_ago(iso):
+    try:
+        dt = datetime.strptime(iso, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+        secs = int((datetime.now(timezone.utc) - dt).total_seconds())
+        if secs < 60: return str(secs) + "s ago"
+        if secs < 3600: return str(secs // 60) + "m ago"
+        if secs < 86400: return str(secs // 3600) + "h ago"
+        return str(secs // 86400) + "d ago"
+    except Exception:
+        return "unknown"
+
+# ---------------------------------------------------------------------------
+# cmd_init helpers
+# ---------------------------------------------------------------------------
+
+def _inject_marker_block(filepath, content, label):
+    """Non-destructively inject content between VICHAR markers. Idempotent."""
+    block = "\n" + VICHAR_MARKER_START + "\n" + content + "\n" + VICHAR_MARKER_END + "\n"
+    if os.path.exists(filepath):
+        text = open(filepath).read()
+        if VICHAR_MARKER_START in text:
+            # Already injected — replace existing block
+            start = text.index(VICHAR_MARKER_START)
+            end = text.index(VICHAR_MARKER_END) + len(VICHAR_MARKER_END)
+            new_text = text[:start].rstrip("\n") + block + text[end:].lstrip("\n")
+            with open(filepath, "w") as f:
+                f.write(new_text)
+            return "updated"
+        else:
+            with open(filepath, "a") as f:
+                f.write(block)
+            return "appended"
+    else:
+        with open(filepath, "w") as f:
+            f.write(block.lstrip("\n"))
+        return "created"
+
+def _remove_marker_block(filepath):
+    """Remove VICHAR-injected block. Return True if anything was removed."""
+    if not os.path.exists(filepath):
+        return False
+    text = open(filepath).read()
+    if VICHAR_MARKER_START not in text:
+        return False
+    start = text.index(VICHAR_MARKER_START)
+    end = text.index(VICHAR_MARKER_END) + len(VICHAR_MARKER_END)
+    new_text = text[:start].rstrip("\n") + "\n" + text[end:].lstrip("\n")
+    with open(filepath, "w") as f:
+        f.write(new_text)
+    return True
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+def cmd_init(args):
+    cwd = os.path.abspath(args.path) if hasattr(args, "path") and args.path else os.getcwd()
+
+    # Determine if already initialised
+    existing_root = find_root(cwd)
+    if existing_root:
+        print(YELLOW + "Already initialised: " + existing_root + RESET)
+        proj = load_project(existing_root)
+        print("  project: " + proj["name"] + "  id: " + proj["id"])
+        return
+
+    # Stamp .vichar/
+    vd = os.path.join(cwd, ".vichar")
+    os.makedirs(vd, exist_ok=True)
+
+    proj_name = os.path.basename(cwd)
+    proj = {"id": str(uuid.uuid4()), "name": proj_name, "schema": "1"}
+    with open(os.path.join(vd, "project.json"), "w") as f:
+        json.dump(proj, f, indent=2)
+
+    # Write agent files into .vichar/
+    with open(os.path.join(vd, "CLAUDE.md"), "w") as f:
+        f.write(CLAUDE_MD_TEMPLATE)
+    with open(os.path.join(vd, "cursor_rules"), "w") as f:
+        f.write(CURSOR_RULES_TEMPLATE)
+    with open(os.path.join(vd, "SCHEMA.md"), "w") as f:
+        f.write(SCHEMA_MD_TEMPLATE)
+
+    # Inject into CLAUDE.md (project root) — single @import line
+    claude_md_path = os.path.join(cwd, "CLAUDE.md")
+    claude_import_line = "@.vichar/CLAUDE.md"
+    claude_status = _inject_marker_block(claude_md_path, claude_import_line, "CLAUDE.md")
+
+    # Inject into .cursor/rules — inline full content (Cursor has no @import)
+    cursor_rules_path = os.path.join(cwd, ".cursor", "rules")
+    cursor_dir = os.path.join(cwd, ".cursor")
+    os.makedirs(cursor_dir, exist_ok=True)
+    cursor_status = _inject_marker_block(cursor_rules_path, CURSOR_RULES_TEMPLATE, ".cursor/rules")
+
+    # Git decision prompt
+    git_msg = ""
+    git_ignore_path = os.path.join(cwd, ".gitignore")
+    if os.path.exists(os.path.join(cwd, ".git")):
+        print("")
+        print(BOLD + "Git detected." + RESET + " How should .vichar/ be tracked?")
+        print("  [L] Local only — add .vichar/ to .gitignore (private reasoning)")
+        print("  [G] Git — commit .vichar/ (shared reasoning, recommended for teams)")
+        print("  [S] Skip")
+        choice = ""
+        try:
+            choice = input("Choice [l/g/s]: ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            choice = "s"
+        if choice.startswith("l"):
+            with open(git_ignore_path, "a") as f:
+                f.write("\n# VICHAR — local reasoning store\n.vichar/\n")
+            git_msg = "  .gitignore: .vichar/ added (local only)"
+        elif choice.startswith("g"):
+            git_msg = "  .vichar/ will be committed (shared reasoning)"
+        else:
+            git_msg = "  .gitignore: skipped"
+
+    # Print banner
+    print("")
+    print(GREEN + BOLD + "  VICHAR initialised" + RESET + "  " + proj_name)
+    print(DIM + "  " + proj["id"] + RESET)
+    print("")
+    print("  .vichar/project.json  " + GREEN + "created" + RESET)
+    print("  .vichar/CLAUDE.md     " + GREEN + "created" + RESET)
+    print("  .vichar/cursor_rules  " + GREEN + "created" + RESET)
+    print("  .vichar/SCHEMA.md     " + GREEN + "created" + RESET)
+    print("  CLAUDE.md             " + GREEN + claude_status + RESET)
+    print("  .cursor/rules         " + GREEN + cursor_status + RESET)
+    if git_msg:
+        print(git_msg)
+    print("")
+    print(DIM + "  Next: vichar capture \"<decision or question>\" --type decision|thread|task" + RESET)
+    print("")
+
+
+def cmd_uninit(args):
+    root = find_root()
+    if not root:
+        print(RED + "No VICHAR project found in this directory tree." + RESET)
+        sys.exit(1)
+
+    removed = []
+    for path, label in [
+        (os.path.join(root, "CLAUDE.md"), "CLAUDE.md"),
+        (os.path.join(root, ".cursor", "rules"), ".cursor/rules"),
+    ]:
+        if _remove_marker_block(path):
+            removed.append(label)
+
+    if removed:
+        print(GREEN + "Removed VICHAR injection from: " + ", ".join(removed) + RESET)
+    else:
+        print(DIM + "No VICHAR markers found in CLAUDE.md or .cursor/rules." + RESET)
+
+    print(DIM + "  .vichar/ directory NOT removed. Delete it manually if desired." + RESET)
+
+
+def cmd_capture(args):
+    root = find_root()
+    if not root:
+        print(RED + "Not in a VICHAR project. Run: vichar init" + RESET)
+        sys.exit(1)
+    _clean_stale_tmp(root)
+    etype = args.type if args.type in ("decision", "thread", "task") else "decision"
+    author = args.author or "human"
+    body = args.body or ""
+    entry = op_capture(root, args.title, etype, body, author)
+    eid = entry["id"]
+    etitle = entry["title"]
+    print(YELLOW + "?" + RESET + " [" + CYAN + eid + RESET + "] " + etitle)
+    if body:
+        print(DIM + "  " + body[:120] + RESET)
+    print(DIM + "  type=" + etype + "  author=" + author + "  status=proposed" + RESET)
+
+
+def cmd_ratify(args):
+    root = find_root()
+    if not root:
+        print(RED + "Not in a VICHAR project." + RESET)
+        sys.exit(1)
+    by = args.by or "human"
+    entry, err = op_ratify(root, args.id, by)
+    if not entry:
+        print(RED + "Error: " + err + RESET)
+        sys.exit(1)
+    if err == "already ratified":
+        print(YELLOW + "Already ratified: " + args.id + RESET)
+    else:
+        print(GREEN + "V" + RESET + " [" + CYAN + entry["id"] + RESET + "] " + entry["title"])
+        print(DIM + "  ratified by " + by + " at " + entry["ratified_at"] + RESET)
+
+
+def cmd_close(args):
+    root = find_root()
+    if not root:
+        print(RED + "Not in a VICHAR project." + RESET)
+        sys.exit(1)
+    entry, err = op_close(root, args.id)
+    if not entry:
+        print(RED + "Error: " + err + RESET)
+        sys.exit(1)
+    print(DIM + "X [" + entry["id"] + "] " + entry["title"] + " (closed)" + RESET)
+
+
+def cmd_log(args):
+    root = find_root()
+    if not root:
+        print(RED + "Not in a VICHAR project. Run: vichar init" + RESET)
+        sys.exit(1)
+    _clean_stale_tmp(root)
+    etype = args.type if hasattr(args, "type") else None
+    include_all = args.all if hasattr(args, "all") else False
+    entries = op_log(root, etype, include_all)
+    proj = load_project(root)
+    print(render_log(entries, proj))
+
+
+def cmd_status(args):
+    root = find_root()
+    if not root:
+        if hasattr(args, "json") and args.json:
+            print('{"error":"no vichar project"}')
+        else:
+            print(RED + "No VICHAR project in this directory tree." + RESET)
+        sys.exit(1)
+    proj = load_project(root)
+    all_entries = load_entries(root)
+    open_entries = [e for e in all_entries if e["status"] != "closed"]
+    proposed = [e for e in open_entries if e["status"] == "proposed"]
+    ratified = [e for e in open_entries if e["status"] == "ratified"]
+    by_type = {"decision": 0, "thread": 0, "task": 0}
+    for e in open_entries:
+        t = e.get("type", "decision")
+        by_type[t] = by_type.get(t, 0) + 1
+    v0_count = len([e for e in all_entries if not e.get("schema")])
+
+    if hasattr(args, "json") and args.json:
+        import json as _json
+        out = {
+            "project": proj["name"], "id": proj["id"],
+            "total": len(all_entries), "open": len(open_entries),
+            "proposed": len(proposed), "ratified": len(ratified),
+            "by_type": by_type, "v0_entries": v0_count,
+        }
+        print(_json.dumps(out, indent=2))
+        return
+
+    parts = [
+        BOLD + proj["name"] + RESET,
+        CYAN + proj["id"][:8] + RESET,
+        str(len(open_entries)) + " open",
+    ]
+    if proposed:
+        parts.append(YELLOW + str(len(proposed)) + " proposed" + RESET)
+    if ratified:
+        parts.append(GREEN + str(len(ratified)) + " ratified" + RESET)
+    for t, n in by_type.items():
+        if n:
+            parts.append(DIM + str(n) + " " + t + "s" + RESET)
+    if v0_count:
+        parts.append(DIM + str(v0_count) + " need migrate" + RESET)
+    print("  ".join(parts))
+
+
+def cmd_migrate(args):
+    root = find_root()
+    if not root:
+        print(RED + "No VICHAR project found." + RESET)
+        sys.exit(1)
+
+    entries = load_entries(root)
+    v0 = [e for e in entries if not e.get("schema")]
+    if not v0:
+        print(DIM + "Nothing to migrate — all entries are schema v1." + RESET)
+        return
+
+    dry = hasattr(args, "dry_run") and args.dry_run
+    print(BOLD + "Migrating " + str(len(v0)) + " entries to schema v1" + RESET + (" (dry run)" if dry else ""))
+
+    if not dry:
+        # Backup first
+        import shutil
+        backup = efile(root) + ".v0.bak"
+        shutil.copy2(efile(root), backup)
+        print(DIM + "  backup: " + backup + RESET)
+
+    proj = load_project(root)
+    count = 0
+    for e in entries:
+        if not e.get("schema"):
+            e.setdefault("project_id", proj["id"])
+            e.setdefault("schema", "1")
+            e.setdefault("status", "proposed")
+            e.setdefault("body", "")
+            e.setdefault("ratified_by", None)
+            e.setdefault("ratified_at", None)
+            e.setdefault("updated_at", e.get("created_at", now_iso()))
+            count += 1
+            mark = DIM + "(dry)" + RESET if dry else GREEN + "migrated" + RESET
+            print("  " + mark + " [" + e["id"] + "] " + e["title"])
+
+    if not dry:
+        save_entries(root, entries)
+        print(GREEN + str(count) + " entries migrated." + RESET)
+    else:
+        print(DIM + str(count) + " would be migrated (no changes written)." + RESET)
+
+
+# ---------------------------------------------------------------------------
+# main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="vichar",
+        description="VICHAR — Versioned Intent and Context History for Agentic Reasoning",
+    )
+    parser.add_argument("--version", action="version", version="vichar " + VERSION)
+    sub = parser.add_subparsers(dest="command")
+
+    # init
+    p_init = sub.add_parser("init", help="Initialise VICHAR in this project")
+    p_init.add_argument("path", nargs="?", default=None, help="Project root (default: cwd)")
+
+    # capture
+    p_cap = sub.add_parser("capture", help="Capture a decision, thread, or task")
+    p_cap.add_argument("title", help="One-line summary")
+    p_cap.add_argument("--type", default="decision",
+                       choices=["decision", "thread", "task"], help="Entry type")
+    p_cap.add_argument("--body", default="", help="Extended reasoning (markdown)")
+    p_cap.add_argument("--author", default="human", help="Who is capturing (e.g. claude-code)")
+
+    # ratify
+    p_rat = sub.add_parser("ratify", help="Mark an entry as human-confirmed")
+    p_rat.add_argument("id", help="Entry ID (8 hex chars)")
+    p_rat.add_argument("--by", default="human", help="Ratified by whom")
+
+    # close
+    p_close = sub.add_parser("close", help="Close an entry")
+    p_close.add_argument("id", help="Entry ID")
+
+    # log
+    p_log = sub.add_parser("log", help="Show open entries")
+    p_log.add_argument("--type", default=None, choices=["decision", "thread", "task"],
+                       help="Filter by type")
+    p_log.add_argument("--all", action="store_true", help="Include closed entries")
+
+    # status
+    p_st = sub.add_parser("status", help="One-line project summary")
+    p_st.add_argument("--json", action="store_true", help="Output as JSON")
+
+    # migrate
+    p_mig = sub.add_parser("migrate", help="Upgrade pre-schema entries to schema v1")
+    p_mig.add_argument("--dry-run", action="store_true", dest="dry_run",
+                       help="Show what would change without writing")
+
+    # uninit
+    sub.add_parser("uninit", help="Remove VICHAR injection from CLAUDE.md + .cursor/rules")
+
+    args = parser.parse_args()
+
+    dispatch = {
+        "init":    cmd_init,
+        "capture": cmd_capture,
+        "ratify":  cmd_ratify,
+        "close":   cmd_close,
+        "log":     cmd_log,
+        "status":  cmd_status,
+        "migrate": cmd_migrate,
+        "uninit":  cmd_uninit,
+    }
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(0)
+
+    fn = dispatch.get(args.command)
+    if fn is None:
+        parser.print_help()
+        sys.exit(1)
+
+    fn(args)
+
+
+if __name__ == "__main__":
+    main()

vichar_server.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""
+VICHAR HTTP Server — run this so agents can POST without direct shell access.
+
+Usage:
+  vichar-server [--port 7474] [--host 127.0.0.1]
+
+Endpoints:
+  GET  /           status page (human-readable)
+  GET  /status     health check (JSON)
+  GET  /log        open entries as JSON  (?type=decision&all=false)
+  POST /capture    {"title": "...", "type": "decision", "body": "...", "author": "..."}
+  POST /ratify     {"id": "abc12345", "by": "human"}
+  POST /close      {"id": "abc12345"}
+
+Agent snippet (zero dependencies):
+  import urllib.request, json
+  def vichar(title, type="decision", body="", author="agent"):
+      data = json.dumps({"title": title, "type": type, "body": body, "author": author}).encode()
+      req = urllib.request.Request("http://localhost:7474/capture", data=data,
+            headers={"Content-Type": "application/json"}, method="POST")
+      try:
+          with urllib.request.urlopen(req, timeout=2) as r: return json.loads(r.read())
+      except Exception: return None  # never block on VICHAR
+"""
+
+import argparse
+import http.server
+import json
+import os
+import sys
+import urllib.parse
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from vichar import (
+    find_root, load_project, load_entries, op_capture, op_ratify, op_close, op_log,
+    VERSION, GREEN, YELLOW, RED, CYAN, BOLD, DIM, RESET,
+)
+
+DEFAULT_PORT = 7474
+DEFAULT_HOST = "127.0.0.1"
+
+# ---------------------------------------------------------------------------
+# Coloured terminal printing (server-side display only)
+# ---------------------------------------------------------------------------
+
+def _print_event(icon, colour, entry_id, title, detail=""):
+    line = colour + icon + RESET + "  [" + CYAN + entry_id + RESET + "] " + title[:72]
+    if detail:
+        line += "  " + DIM + detail + RESET
+    print(line, flush=True)
+
+# ---------------------------------------------------------------------------
+# HTTP handler
+# ---------------------------------------------------------------------------
+
+class VICHARHandler(http.server.BaseHTTPRequestHandler):
+
+    def log_message(self, fmt, *a):
+        pass  # suppress default access log
+
+    def send_json(self, code, payload):
+        body = json.dumps(payload, indent=2).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def send_html(self, code, html):
+        body = html.encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def read_body(self):
+        length = int(self.headers.get("Content-Length", 0))
+        if length <= 0:
+            return dict()
+        raw = self.rfile.read(length)
+        if not raw:
+            return dict()
+        try:
+            return json.loads(raw)
+        except Exception:
+            return dict()
+
+    def do_GET(self):
+        parsed = urllib.parse.urlparse(self.path)
+        params = dict(urllib.parse.parse_qsl(parsed.query))
+        path = parsed.path
+
+        if path in ("/", ""):
+            proj = load_project(self.server.root)
+            entries = load_entries(self.server.root)
+            open_e = [e for e in entries if e.get("status") != "closed"]
+            proposed = [e for e in open_e if e.get("status") == "proposed"]
+
+            rows = ""
+            for e in open_e[:30]:
+                icon = "?" if e["status"] == "proposed" else ("V" if e["status"] == "ratified" else "o")
+                colour = "#f5a623" if e["status"] == "proposed" else ("#4caf50" if e["status"] == "ratified" else "#e53935")
+                rows += (
+                    "<tr><td style='color:" + colour + "'>" + icon + "</td>"
+                    "<td><code>" + e["id"] + "</code></td>"
+                    "<td>" + e["type"] + "</td>"
+                    "<td>" + e["title"][:80] + "</td></tr>\n"
+                )
+
+            html = (
+                "<!DOCTYPE html><html><head><meta charset=utf-8>"
+                "<title>VICHAR — " + proj["name"] + "</title>"
+                "<style>body{font-family:monospace;background:#111;color:#ccc;padding:2em}"
+                "h1{color:#fff}table{border-collapse:collapse;width:100%}"
+                "td,th{padding:.4em .8em;border-bottom:1px solid #333;text-align:left}"
+                "code{color:#7ec8e3}</style></head><body>"
+                "<h1>VICHAR</h1>"
+                "<p><b>" + proj["name"] + "</b> &nbsp;<code>" + proj["id"] + "</code></p>"
+                "<p>" + str(len(open_e)) + " open &nbsp; " + str(len(proposed)) + " proposed &nbsp; version " + VERSION + "</p>"
+                "<table><tr><th>st</th><th>id</th><th>type</th><th>title</th></tr>"
+                + rows +
+                "</table>"
+                "<hr><p style='color:#555'>POST /capture &nbsp; POST /ratify &nbsp; POST /close &nbsp; GET /log &nbsp; GET /status</p>"
+                "</body></html>"
+            )
+            self.send_html(200, html)
+            return
+
+        if path == "/status":
+            proj = load_project(self.server.root)
+            entries = load_entries(self.server.root)
+            open_e = [e for e in entries if e.get("status") != "closed"]
+            self.send_json(200, {
+                "status": "ok",
+                "project": proj["name"],
+                "id": proj["id"],
+                "version": VERSION,
+                "open": len(open_e),
+                "total": len(entries),
+            })
+            return
+
+        if path == "/log":
+            proj = load_project(self.server.root)
+            etype = params.get("type")
+            include_all = params.get("all", "false").lower() == "true"
+            entries = op_log(self.server.root, etype, include_all)
+            self.send_json(200, {"project": proj, "entries": entries, "count": len(entries)})
+            return
+
+        self.send_json(404, {"error": "not found", "path": path})
+
+    def do_POST(self):
+        data = self.read_body()
+        path = urllib.parse.urlparse(self.path).path
+
+        if path == "/capture":
+            title = data.get("title", "").strip()
+            if not title:
+                self.send_json(400, {"error": "title is required"})
+                return
+            entry = op_capture(
+                self.server.root, title,
+                data.get("type", "decision"),
+                data.get("body", ""),
+                data.get("author", "agent"),
+            )
+            _print_event("?", YELLOW, entry["id"], entry["title"],
+                         "type=" + entry["type"] + " author=" + entry["author"])
+            self.send_json(201, {"id": entry["id"], "status": "proposed"})
+            return
+
+        if path == "/ratify":
+            eid = data.get("id", "").strip()
+            if not eid:
+                self.send_json(400, {"error": "id is required"})
+                return
+            entry, err = op_ratify(self.server.root, eid, data.get("by", "human"))
+            if not entry:
+                self.send_json(404, {"error": err})
+                return
+            if err == "already ratified":
+                self.send_json(200, {"id": entry["id"], "status": "ratified", "note": "already ratified"})
+                return
+            _print_event("V", GREEN, entry["id"], entry["title"],
+                         "ratified_by=" + entry["ratified_by"])
+            self.send_json(200, {"id": entry["id"], "status": "ratified"})
+            return
+
+        if path == "/close":
+            eid = data.get("id", "").strip()
+            if not eid:
+                self.send_json(400, {"error": "id is required"})
+                return
+            entry, err = op_close(self.server.root, eid)
+            if not entry:
+                self.send_json(404, {"error": err})
+                return
+            _print_event("X", DIM, entry["id"], entry["title"], "closed")
+            self.send_json(200, {"id": entry["id"], "status": "closed"})
+            return
+
+        self.send_json(404, {"error": "not found", "path": path})
+
+# ---------------------------------------------------------------------------
+# Server entrypoint
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="VICHAR HTTP server")
+    parser.add_argument("--port", type=int, default=DEFAULT_PORT)
+    parser.add_argument("--host", default=DEFAULT_HOST)
+    args = parser.parse_args()
+
+    root = find_root()
+    if not root:
+        print(RED + "No VICHAR project found. Run: vichar init" + RESET)
+        sys.exit(1)
+
+    proj = load_project(root)
+
+    # Port conflict detection
+    import socket
+    try:
+        test = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        test.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        test.bind((args.host, args.port))
+        test.close()
+    except OSError:
+        print(RED + "Port " + str(args.port) + " is already in use." + RESET)
+        print(DIM + "  Is another vichar-server running? Try: lsof -i :" + str(args.port) + RESET)
+        sys.exit(1)
+
+    server = http.server.HTTPServer((args.host, args.port), VICHARHandler)
+    server.root = root
+
+    url = "http://" + args.host + ":" + str(args.port)
+    print("")
+    print(BOLD + "  VICHAR server" + RESET + "  " + CYAN + proj["name"] + RESET +
+          "  " + DIM + proj["id"] + RESET)
+    print("  " + url)
+    print(DIM + "  POST /capture  POST /ratify  POST /close  GET /log  GET /status" + RESET)
+    print(DIM + "  Ctrl+C to stop" + RESET)
+    print("")
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n" + DIM + "VICHAR server stopped." + RESET)
+
+
+if __name__ == "__main__":
+    main()