xcoding 0.1.0__py3-none-any.whl

xcode/ui.py

@@ -0,0 +1,349 @@
+"""Look & feel: themes, the ghost+trees logo, the welcome box, and the
+input header. Kept separate from cli.py so the chrome is easy to tweak.
+"""
+
+from __future__ import annotations
+
+import json
+import random
+import time
+from pathlib import Path
+from typing import Callable
+
+from rich.box import ROUNDED
+from rich.console import Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+PREFS = Path(".xcode") / "ui.json"
+# The source logo we render into the terminal (lives at the project root).
+LOGO = Path(__file__).resolve().parent.parent / "logo.png"
+
+# The little glyph that spins while we think, and the words it cycles through.
+SPIN_GLYPHS = "✻✷✶✳✺✸"
+THINKING_WORDS = [
+    "Envisioning", "Thinking", "Pondering", "Cooking", "Conjuring",
+    "Crunching", "Noodling", "Percolating", "Scheming", "Manifesting",
+    "Summoning", "Brewing",
+]
+TIPS = [
+    "Use /btw to ask a quick side question without interrupting",
+    "Press shift+tab to cycle normal → auto → plan mode",
+    "Run /theme matrix to go full hacker mode",
+    "Type /clear to wipe the conversation and start fresh",
+    "Hit ↑/↓ or w/s to move through any menu, enter to pick",
+    "Try 'fix typecheck errors'",
+    "Ask me to 'make it more compact'",
+    "Use @file to attach files to your message",
+    "Press ctrl+z to undo your last edit in the input",
+    "Type / to see every slash command with descriptions",
+    "Use /model to switch the active model on the fly",
+    "Run /init to explore the project and write an XCODE.md",
+    "Use /compact to summarize and free up context",
+    "Try 'explain this stack trace'",
+    "Try 'write a commit message for my changes'",
+    "Try 'find where we handle login'",
+    "Ask 'how does <filepath> work?'",
+    "Use /resume to pick up a previous session",
+    "Use /memory to see what the project memory holds",
+    "Use /perms reset to clear saved permissions",
+    "Try 'add tests for the auth module'",
+    "Press ctrl+c to cancel the current input",
+]
+
+# Each theme picks colors for the border, the ghost, the trees, accents, etc.
+THEMES: dict[str, dict] = {
+    "ghost": {  # default — clean white ghost on black
+        "border": "grey93", "ghost": "grey93", "eyes": "grey42",
+        "tree": "grey58", "accent": "white", "title": "bold white",
+        "user": "bold white", "tool": "grey50", "mode": "white",
+    },
+    "matrix": {
+        "border": "green", "ghost": "green1", "eyes": "bright_green",
+        "tree": "green3", "accent": "green1", "title": "bold green",
+        "user": "bold green", "tool": "green4", "mode": "green",
+    },
+    "dracula": {
+        "border": "purple", "ghost": "grey93", "eyes": "bright_magenta",
+        "tree": "spring_green3", "accent": "orchid", "title": "bold purple",
+        "user": "bold orchid", "tool": "grey50", "mode": "orchid",
+    },
+    "ember": {
+        "border": "dark_orange3", "ghost": "wheat1", "eyes": "orange1",
+        "tree": "dark_olive_green3", "accent": "orange1", "title": "bold orange1",
+        "user": "bold orange1", "tool": "grey50", "mode": "dark_orange",
+    },
+    "mono": {
+        "border": "grey50", "ghost": "grey93", "eyes": "grey70",
+        "tree": "grey58", "accent": "grey85", "title": "bold white",
+        "user": "bold white", "tool": "grey42", "mode": "grey70",
+    },
+}
+
+DEFAULT_THEME = "ghost"
+
+def _ghost_text(theme: dict) -> Text:
+    """Tiny compact ghost facing right."""
+    g = theme["ghost"]
+    e = theme["eyes"]
+
+    # Ghost facing RIGHT
+    logo_lines = [
+        " ▓▓▓▓▓",
+        "▓▓▓▓▓▓▓",
+        " ▓▒▓▓▒▓",
+        "▓▓▓▓▓▓▓",
+        " ▓  ▓",
+    ]
+
+    t = Text()
+    for line in logo_lines:
+        # Color the eyes (▒) differently
+        if "▒" in line:
+            parts = line.split("▒")
+            for i, part in enumerate(parts):
+                if i > 0:
+                    t.append("▒", style=e)
+                t.append(part, style=g)
+        else:
+            t.append(line, style=g)
+        t.append("\n")
+    t.rstrip()
+    return t
+
+
+def _neighbors(x, y, w, h):
+    if x > 0: yield x - 1, y
+    if x < w - 1: yield x + 1, y
+    if y > 0: yield x, y - 1
+    if y < h - 1: yield x, y + 1
+
+
+def _largest_blob(mask, w, h):
+    """(bounding box, mask) of the biggest connected True region — used to crop
+    to the ghost and to drop the little floating sparkles around it."""
+    from collections import deque
+    seen = [[False] * w for _ in range(h)]
+    best, best_box, best_cells = 0, (0, 0, w - 1, h - 1), None
+    for sy in range(h):
+        for sx in range(w):
+            if not mask[sy][sx] or seen[sy][sx]:
+                continue
+            dq = deque([(sx, sy)]); seen[sy][sx] = True
+            cells, l, t, r, b = [], sx, sy, sx, sy
+            while dq:
+                x, y = dq.popleft(); cells.append((x, y))
+                l, t, r, b = min(l, x), min(t, y), max(r, x), max(b, y)
+                for nx, ny in _neighbors(x, y, w, h):
+                    if mask[ny][nx] and not seen[ny][nx]:
+                        seen[ny][nx] = True; dq.append((nx, ny))
+            if len(cells) > best:
+                best, best_box, best_cells = len(cells), (l, t, r, b), cells
+    keep = [[False] * w for _ in range(h)]
+    for x, y in (best_cells or []):
+        keep[y][x] = True
+    return best_box, keep
+
+
+def _logo_segments(width: int, rows: int):
+    """Read logo.png and label every pixel as background / body / feature.
+
+    The logo is RGBA with a *transparent* field, so the alpha channel tells us
+    the ghost from the background directly. We: (1) sample at high res, (2) take
+    the largest opaque blob as the ghost (dropping the floating sparkles),
+    (3) crop + transparent-pad to it, (4) at display size, split the ghost into
+    its white *body* and its enclosed black *features* (the eyes + </> mouth).
+    The black outline rim is folded into the body so the silhouette stays solid.
+    Result codes: 0=bg, 1=body, 2=feature.
+    """
+    from collections import deque
+
+    from PIL import Image, ImageOps
+
+    base = 220
+    im = Image.open(LOGO).convert("RGBA").resize((base, base))
+    apx = im.load()
+    opaque = [[apx[x, y][3] >= 128 for x in range(base)] for y in range(base)]
+    (l, t, r, b), _ = _largest_blob(opaque, base, base)
+    im = im.crop((l, t, r + 1, b + 1))
+    im = ImageOps.expand(im, border=max(2, (r - l) // 20), fill=(0, 0, 0, 0))
+    im = im.resize((width, rows))
+
+    px = im.load()
+    opq = [[px[x, y][3] >= 128 for x in range(width)] for y in range(rows)]
+    _, ghost = _largest_blob(opq, width, rows)      # drop resized sparkle bits
+
+    def lum(x, y):
+        p = px[x, y]
+        return (p[0] * 299 + p[1] * 587 + p[2] * 114) // 1000
+
+    dark = [[ghost[y][x] and lum(x, y) < 128 for x in range(width)] for y in range(rows)]
+
+    # outline = dark rim touching the background; flood it so only the enclosed
+    # dark (eyes + mouth) stays a 'feature'.
+    outline = [[False] * width for _ in range(rows)]
+    dq = deque()
+    for y in range(rows):
+        for x in range(width):
+            if dark[y][x] and any(not ghost[ny][nx]
+                                  for nx, ny in _neighbors(x, y, width, rows)):
+                outline[y][x] = True; dq.append((x, y))
+    while dq:
+        x, y = dq.popleft()
+        for nx, ny in _neighbors(x, y, width, rows):
+            if dark[ny][nx] and not outline[ny][nx]:
+                outline[ny][nx] = True; dq.append((nx, ny))
+
+    out = [[0] * width for _ in range(rows)]
+    for y in range(rows):
+        for x in range(width):
+            if not ghost[y][x]:
+                out[y][x] = 0                       # background → transparent
+            elif dark[y][x] and not outline[y][x]:
+                out[y][x] = 2                       # enclosed feature → black
+            else:
+                out[y][x] = 1                       # body (fill + outline rim)
+    return out
+
+
+def logo(theme: dict, width: int = 26) -> Text:
+    """Render logo.png into the terminal with truecolor half-blocks.
+
+    Each character is the 'upper half block' ▀ whose *foreground* paints the
+    top pixel and *background* paints the bottom pixel — so one cell carries
+    two stacked pixels. The body fills with the theme's ghost colour; the eyes
+    and </> mouth fill black; the field stays transparent.
+    """
+    from rich.style import Style
+
+    rows = width + (width & 1)                      # even → 2 pixels per cell
+    try:
+        seg = _logo_segments(width, rows)
+    except Exception:
+        return _ghost_text(theme)                   # no Pillow / no file → ASCII
+
+    fill = {0: None, 1: theme["ghost"], 2: "grey3"}
+    t = Text()
+    for cr in range(rows // 2):
+        for c in range(width):
+            top = fill[seg[2 * cr][c]]
+            bot = fill[seg[2 * cr + 1][c]]
+            if top and bot:
+                t.append("▀", style=Style(color=top, bgcolor=bot))
+            elif top:
+                t.append("▀", style=Style(color=top))
+            elif bot:
+                t.append("▄", style=Style(color=bot))
+            else:
+                t.append(" ")
+        t.append("\n")
+    t.rstrip()
+    return t
+
+
+def welcome(theme: dict, model: str, cwd: str, notes: str = "") -> Panel:
+    """Landscape welcome card: ghost on the left, info on the right."""
+    info = Group(
+        Text("xcode", style=theme["title"]),
+        Text("local-model coding agent", style=theme["tool"]),
+        Text(""),
+        Text(model, style=theme["accent"]),
+        Text(cwd + (f"  ·{notes}" if notes else ""), style=theme["tool"]),
+    )
+    grid = Table.grid(padding=(0, 2))
+    grid.add_column(justify="left")
+    grid.add_column(justify="left")
+    grid.add_row(_ghost_text(theme), info)
+
+    return Panel(grid, box=ROUNDED, border_style=theme["border"],
+                 padding=(0, 2), expand=False)
+
+
+def status_line(theme: dict, mode: str, tokens: int, budget: int,
+                model: str) -> Text:
+    t = Text("  ")
+    if mode == "auto":
+        t.append("⏵⏵ auto mode on ", style=f"bold {theme['mode']}")
+        t.append("(shift+tab to cycle)", style="dim")
+    elif mode == "plan":
+        t.append("◷ plan mode ", style=f"bold {theme['mode']}")
+        t.append("(read-only · shift+tab to cycle)", style="dim")
+    else:
+        t.append("·· normal mode ", style=theme["mode"])
+        t.append("(shift+tab to cycle)", style="dim")
+    pct = min(100, int(100 * tokens / budget)) if budget else 0
+    tok_color = "green" if pct < 60 else "yellow" if pct < 85 else "red"
+    t.append("  ·  ")
+    t.append(f"~{tokens/1000:.1f}k/{budget//1000}k", style=tok_color)
+    t.append("  ·  ")
+    t.append(f"● {model}", style=theme["accent"])
+    return t
+
+
+# ------------------------------------------------------------- thinking
+
+class ThinkingStatus:
+    """A live, self-animating status line shown while the model works.
+
+    Renders like Claude Code's:
+
+        ✻ Envisioning… (48s · ↓ 1.7k tokens · 2 shells running)  ⎿ Tip: Use /btw to ask a quick side question
+
+    Drive it with a rich.live.Live; the glyph spins, the timer ticks and the
+    token counter climbs on every refresh — no extra work needed from caller.
+    Mutate `.tokens` and `.preview` from the stream loop to update them.
+    """
+
+    def __init__(self, theme: dict, get_shells: Callable[[], int] | None = None):
+        self.theme = theme
+        self.get_shells = get_shells or (lambda: 0)
+        self.start = time.monotonic()
+        self.word = random.choice(THINKING_WORDS)
+        self.tip = random.choice(TIPS)
+        self.tokens = 0
+        self.preview = ""
+
+    def __rich__(self) -> Group:
+        elapsed = time.monotonic() - self.start
+        glyph = SPIN_GLYPHS[int(elapsed * 6) % len(SPIN_GLYPHS)]
+        shells = self.get_shells()
+
+        head = Text()
+        head.append(f"{glyph} ", style=self.theme["accent"])
+        head.append(f"{self.word}… ", style=self.theme["title"])
+        meta = f"({int(elapsed)}s · ↓ {self.tokens / 1000:.1f}k tokens"
+        if shells:
+            meta += f" · {shells} shell{'s' if shells != 1 else ''} running"
+        meta += ")"
+        head.append(meta, style="dim")
+        
+        lines = [head]
+        if self.preview:
+            snippet = self.preview.replace("\n", " ").strip()[-80:]
+            lines.append(Text(f"  {snippet}", style="dim"))
+        lines.append(Text(f"  ⎿ Tip: {self.tip}", style="dim"))
+        return Group(*lines)
+
+
+# ----------------------------------------------------------------- prefs
+
+def load_prefs() -> dict:
+    if PREFS.exists():
+        try:
+            return json.loads(PREFS.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+    return {"theme": DEFAULT_THEME, "mode": "normal"}
+
+
+def save_prefs(prefs: dict) -> None:
+    try:
+        PREFS.parent.mkdir(parents=True, exist_ok=True)
+        PREFS.write_text(json.dumps(prefs, indent=2), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def get_theme(name: str) -> dict:
+    return THEMES.get(name, THEMES[DEFAULT_THEME])

xcoding-0.1.0.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: xcoding
+Version: 0.1.0
+Summary: A local-model coding agent — Claude Code, but powered by Ollama or llama.cpp.
+Author: c7s89r nzv
+Maintainer: c7s89r nzv
+License: MIT
+Project-URL: Homepage, https://github.com/c7s89r/xcode
+Project-URL: Repository, https://github.com/c7s89r/xcode
+Project-URL: Issues, https://github.com/c7s89r/xcode/issues
+Keywords: cli,coding-agent,ollama,llama.cpp,ai,local-llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.30.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: prompt_toolkit>=3.0.0
+Requires-Dist: discord.py>=2.3.0
+Dynamic: license-file
+
+# xcode
+
+A local-model coding agent — like Claude Code, but it talks to a model
+running on your own machine instead of a cloud API.
+
+> **✅ Works with [Ollama](https://ollama.com) for now.** Just install Ollama,
+> pull a tool-capable model, then `pip install xcode` and run `xcode`.
+> (llama.cpp support is in too, but Ollama is the tested path.)
+
+It auto-detects whichever backend is running, gives the model tools to read/write
+files and run shell commands, and loops until your task is done. Every file write
+and every shell command asks for your approval first.
+
+### Quick start (Ollama)
+
+```bash
+ollama serve
+ollama pull qwen2.5-coder     # a model that's good at tool use
+pip install xcode
+xcode
+```
+
+## Install
+
+```bash
+pip install xcode
+```
+
+Then just run `xcode` from any project folder.
+
+Or from source:
+
+```bash
+pip install -e .
+```
+
+(Python 3.9+. Pulls in `openai`, `httpx`, `rich`.)
+
+## Run a backend
+
+**Ollama** (easiest — supports tool-calling natively):
+
+```bash
+ollama serve
+ollama pull qwen2.5-coder        # a model that's good at tool use
+```
+
+**llama.cpp** (raw GGUF files):
+
+```bash
+llama-server -m your-model.gguf   # listens on :8080, OpenAI-compatible
+```
+
+> Tool-calling quality depends heavily on the model. Use a model trained for it
+> (e.g. `qwen2.5-coder`, `llama3.1`, `mistral-nemo`). Tiny models will struggle.
+
+## Use it
+
+```bash
+xcode
+# or:  python -m xcode
+```
+
+Then just talk to it:
+
+```
+› add a /health endpoint to app.py that returns {"ok": true}
+```
+
+In-REPL commands: `/help`, `/models`, `/model`, `/init`, `/todos`, `/perms`,
+`/compact`, `/sessions`, `/resume`, `/reset`, `/exit`.
+
+- Replies **stream** live; the prompt shows a **context meter** (`~3.2k/8k`).
+- Writes/commands ask `y / n / a`; **a** ("always") is saved to
+  `.xcode/permissions.json`. Edits show a **colored diff** preview.
+- Attach files inline with `@path` (e.g. `explain @xcode/agent.py`).
+- The agent tracks a **todo list** for multi-step work (`/todos` to view).
+- Old turns are **auto-compacted** when the context meter fills; `/compact`
+  forces it. Conversations are **saved** per project — `xcode --resume` or
+  `/resume` to pick up where you left off.
+- Drop an **XCODE.md** at the repo root (or run `/init`) and it's auto-loaded
+  as project memory.
+
+### Modes (shift+tab to cycle)
+
+- **·· normal** — asks before writes/commands
+- **⏵⏵ auto** — runs & writes without asking
+- **◷ plan** — read-only; explores but makes no changes
+
+### Sub-agents, web, MCP, hooks
+
+- `spawn_agent` lets the model delegate an isolated subtask to a fresh context.
+- `web_search` (DuckDuckGo) and `web_fetch` give it internet access.
+- Drop a `.xcode/settings.json` to add **hooks** (run a formatter after every
+  edit), **env** vars, seed **permissions**, and declare **MCP servers**:
+
+```json
+{
+  "hooks": { "after_edit": ["ruff format {path}"] },
+  "permissions": { "commands": ["git", "ls", "python"] },
+  "mcpServers": {
+    "fs": { "command": "npx",
+            "args": ["-y", "@modelcontextprotocol/server-filesystem", "."] }
+  }
+}
+```
+
+MCP tools show up to the model as `mcp__<server>__<tool>`.
+
+### Headless / scripting
+
+```bash
+xcode -p "summarize what this repo does"          # read-only, prints, exits
+xcode -p "bump the version to 0.2.0" --yes        # auto-approve writes
+xcode -p "what changed?" --resume                 # continue last session
+```
+
+## Configuration (env vars)
+
+| var              | meaning                                              |
+|------------------|------------------------------------------------------|
+| `XCODE_BASE_URL` | point straight at any OpenAI-compatible `/v1` URL    |
+| `XCODE_MODEL`    | force a specific model name                          |
+| `XCODE_API_KEY`  | token if your endpoint needs one (default `local`)   |
+| `XCODE_MAX_STEPS`| max tool round-trips per turn (default 25)           |
+
+## How it works
+
+```
+cli.py       REPL + permission prompts (the only UI code)
+agent.py     the loop: model ⇄ tools until it stops calling tools
+backends.py  auto-detect Ollama (:11434) / llama.cpp (:8080)
+tools.py     read_file, write_file, list_dir, run_command + JSON schemas
+config.py    system prompt + knobs
+```
+
+## Roadmap
+
+- [x] Streaming token output
+- [x] `edit_file` (targeted edits instead of full rewrites)
+- [x] `grep` / `glob_files` search tools
+- [x] Persistent permission rules ("always allow `git …`")
+- [x] `/model` picker + smart default-model selection
+- [x] Context compaction for long sessions + context meter
+- [x] Diff-style preview when confirming edits
+- [x] Project memory (XCODE.md) + `/init`
+- [x] Todo/task tracking
+- [x] Session save + `--resume`
+- [x] Headless mode (`-p`) + `@file` mentions
+- [x] Web fetch / web search tools
+- [x] Sub-agents (delegate a subtask to a fresh context)
+- [x] MCP server support
+- [x] Hooks + settings.json
+- [x] Themes + ghost logo, shift+tab mode cycling (normal/auto/plan)
+
+## Made by
+
+Built by **@c7s89r** (nzv).
+
+- GitHub: [@c7s89r](https://github.com/c7s89r)
+- Discord: `c7s89r`
+
+MIT licensed — see [LICENSE](LICENSE).

xcoding-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+xcode/__init__.py,sha256=bfuPcvsqB0fFWkasX5F3XKEtGuwBM6djqJiXbUHLgcI,108
+xcode/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+xcode/agent.py,sha256=UUK78OArJNd0OGC_aCJhQcEl-klXik-_CJX417aN7XU,14149
+xcode/backends.py,sha256=CEfkyzjGn-1psVr4GZKiE--Ggprqd82MMjaJsYrN3yk,4636
+xcode/cli.py,sha256=ciBSoB0JBGI3fqNQVXpC4K70xD6cfi5LyignSVmbVEg,24391
+xcode/config.py,sha256=eLuOCJsZkvzk4bpiJRMHyi1tijIslNVejciiA74cwa8,3883
+xcode/hooks.py,sha256=zqWfe5dLZ_H09M1IPqGaTR5c8b_qA5mTyPPlIO3614k,2402
+xcode/input_bar.py,sha256=dzCxTe9t2SnKhpph8oNKsoBZgMBpHoaqkO2AIzp2Xjs,13839
+xcode/mcp.py,sha256=U4OQYwgaTEmF7cXM1rl8U58AotjbMGU1F8PXAU_TrLs,5725
+xcode/memory.py,sha256=PNAr4bbzB5yjAntFjHckoWCfUH0X2VpazkCqmrQ2JcA,1217
+xcode/permissions.py,sha256=EeggrynUfP_Yjm0oqMoLrP44IN9u9egN1WeA9HWNyiE,2661
+xcode/session.py,sha256=KcjBR-PmVEJF5JDTMk7WphPi8YcpYofg-NTisv9V588,1757
+xcode/tools.py,sha256=-eB4A5lnHo9hPIX-xSsxYhufsBkqD62jHaPFbKskQYk,17564
+xcode/ui.py,sha256=qJ6_21hLxF_qdOEISxQdYC8JRnHEIFH1zDS_2eGTk9w,13477
+xcoding-0.1.0.dist-info/licenses/LICENSE,sha256=E2ul7pgp6YEzKrl_f3mwu6X4P02Ap82BqMW0dyO7r20,1069
+xcoding-0.1.0.dist-info/METADATA,sha256=OgjdcmLzf0Slew0VuJkuOoxFsK6J1vS3_UH-Kghp3l4,6210
+xcoding-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+xcoding-0.1.0.dist-info/entry_points.txt,sha256=qvTz6nsCXyjnhJwuI6OQ7At8x3YlxWUTo1KhacIoXWk,41
+xcoding-0.1.0.dist-info/top_level.txt,sha256=81BFRvNclHTxdaBmzzIyfb_JaVM_fwWEGSRkMhsoRBs,6
+xcoding-0.1.0.dist-info/RECORD,,

xcoding-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
+

xcoding-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xcode = xcode.cli:main

xcoding-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 c7s89r (nzv)
+
+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.

xcoding-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xcode