loom-code 0.1.1__py3-none-any.whl

loom_code/worktree.py

@@ -0,0 +1,134 @@
+"""Git worktree lifecycle for session isolation.
+
+An *isolated* session edits in its own git worktree on branch
+``loom/<session_id>`` — a separate working copy of the same repo — so
+two concurrent sessions on one repo (two ``loom-code`` terminals, two
+desktop chat tabs) can't collide on disk. When done, the branch is
+either merged into the base branch or discarded, and the worktree is
+removed.
+
+This is the SHARED lifecycle: the loom-code CLI drives it via
+``/isolate`` `/review` `/merge` `/discard`, and the desktop sidecar can
+use the same functions instead of its own copy.
+
+Git-only. Every function degrades gracefully — git failures come back
+as ``(None, error)`` / ``(False, error)`` rather than raising, so a
+bad git state never crashes the REPL.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class WorktreeInfo:
+    """A live session worktree: where it is, its branch, and the base
+    branch it was forked from (and will merge back into)."""
+
+    path: Path
+    branch: str
+    base: str
+
+
+def _git(
+    cwd: Path | str, args: list[str], *, timeout: int = 60
+) -> tuple[int, str, str]:
+    """Run a git subcommand in ``cwd``. Returns (returncode, out, err);
+    never raises on a non-zero exit — callers inspect the code."""
+    try:
+        proc = subprocess.run(
+            ["git", *args],
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        return 1, "", str(exc)
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+def is_git_repo(root: Path | str) -> bool:
+    return (Path(root) / ".git").exists()
+
+
+def worktree_path(root: Path | str, session_id: str) -> Path:
+    return Path(root) / ".loom" / "worktrees" / session_id
+
+
+def branch_name(session_id: str) -> str:
+    # session ids (chat-<...> / ULIDs) are ref-safe; "loom/" namespaces
+    # them so they're easy to spot + bulk-clean.
+    return f"loom/{session_id}"
+
+
+def current_branch(root: Path | str) -> str:
+    rc, out, _ = _git(root, ["symbolic-ref", "--short", "HEAD"])
+    return out.strip() if rc == 0 and out.strip() else "HEAD"
+
+
+def create(
+    root: Path | str, session_id: str
+) -> tuple[WorktreeInfo | None, str]:
+    """Create a worktree for ``session_id``. Returns ``(info, "")`` or
+    ``(None, error)``. Idempotent-ish: if the branch already exists
+    (re-isolate after a discard) it's reused."""
+    root = Path(root)
+    if not is_git_repo(root):
+        return None, "not a git repository"
+    wt = worktree_path(root, session_id)
+    branch = branch_name(session_id)
+    base = current_branch(root)
+    try:
+        wt.parent.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        return None, f"mkdir failed: {exc}"
+    rc, _out, err = _git(root, ["worktree", "add", str(wt), "-b", branch])
+    if rc != 0:
+        rc2, _o2, err2 = _git(root, ["worktree", "add", str(wt), branch])
+        if rc2 != 0:
+            return None, (err or err2).strip()
+    return WorktreeInfo(path=wt, branch=branch, base=base), ""
+
+
+def diff(info: WorktreeInfo) -> tuple[str, str]:
+    """Unified diff of the worktree (committed-on-branch + uncommitted)
+    vs the base branch. Returns ``(diff_text, error)``."""
+    rc, out, err = _git(info.path, ["diff", info.base])
+    if rc != 0:
+        return "", err.strip()
+    return out, ""
+
+
+def merge(root: Path | str, info: WorktreeInfo) -> tuple[bool, str]:
+    """Commit the worktree's uncommitted edits (only when dirty), then
+    merge its branch into the base branch from the MAIN tree. Returns
+    ``(ok, error)``. Refuses if the main tree isn't on the base branch
+    (to avoid merging into the wrong branch); aborts on conflict."""
+    root = Path(root)
+    rc, out, _ = _git(info.path, ["status", "--porcelain"])
+    if rc == 0 and out.strip():
+        _git(info.path, ["add", "-A"])
+        _git(info.path, ["commit", "-m", f"loom session {info.branch}"])
+    cur = current_branch(root)
+    if cur != info.base:
+        return False, (
+            f"the main working tree is on '{cur}', not the session's "
+            f"base '{info.base}' — switch back before merging"
+        )
+    rc, _o, err = _git(root, ["merge", "--no-edit", info.branch])
+    if rc != 0:
+        _git(root, ["merge", "--abort"])
+        return False, f"merge conflict: {err.strip()}"
+    return True, ""
+
+
+def remove(root: Path | str, info: WorktreeInfo) -> None:
+    """Remove the worktree + delete its branch. Best-effort — used on
+    both discard and post-merge cleanup."""
+    root = Path(root)
+    _git(root, ["worktree", "remove", "--force", str(info.path)])
+    _git(root, ["branch", "-D", info.branch])

loom_code-0.1.1.dist-info/METADATA

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: loom-code
+Version: 0.1.1
+Summary: loom-code — a loomflow-native terminal coding agent
+Author: Anupam Nautiyal
+License: MIT License
+        
+        Copyright (c) 2026 Anupam Nautiyal
+        
+        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/Anurich/loomflow-cli
+Project-URL: Repository, https://github.com/Anurich/loomflow-cli
+Project-URL: Issues, https://github.com/Anurich/loomflow-cli/issues
+Keywords: ai,agent,cli,coding-assistant,llm,loomflow
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: loomflow[litellm,mcp,web]<0.11,>=0.10.23
+Requires-Dist: rich>=13
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: anthropic
+Requires-Dist: openai
+Requires-Dist: graphifyy<0.9,>=0.8.11
+Requires-Dist: jedi>=0.19
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: bump-my-version>=0.30; extra == "dev"
+Dynamic: license-file
+
+# loom-code
+
+**A terminal coding agent built on [loomflow](https://github.com/Anurich/LoomFlow).**
+Plans before it codes, asks before it breaks things, works with any model —
+including free ones.
+
+```
+›  add a retry decorator to the http client
+
+● loom
+Added `retry(max_attempts=3, backoff=2.0)` to http/client.py and wired it
+onto get() and post(). Tests pass (14/14).
+───────────────────────────────────────────── 12,431 in · 217 out · $0.0043
+```
+
+loom-code is a thin terminal shell — the brain is loomflow. The CLI detects
+your project, builds a loomflow `Agent`, streams the run to your terminal,
+and gates destructive tool calls behind an approval prompt. Everything
+load-bearing — the agent loop, tools, planning, memory — is loomflow.
+
+## Highlights
+
+- **Plans before it codes.** Every task gets a living plan
+  (TodoWrite-style), visible as it progresses, hard to drift from.
+- **Any model, including free ones.** OpenAI, Anthropic, NVIDIA's free
+  NIM tier, local Ollama, or anything LiteLLM routes (Groq, Together,
+  Azure, Bedrock, Vertex…). `/set_model` walks you through provider →
+  API key → model with arrow-key menus.
+- **Claude-Code-style permissions.** Reads are lenient, writes are
+  strict. Every write/edit/shell command routes through an approval
+  gate with a unified-diff preview. Allow/ask/deny rules, approval
+  modes (`default` / `accept-edits` / `plan` / `yolo`), and an
+  optional OS-level bash sandbox (`--sandbox`).
+- **Specialist sub-agents on demand.** The main loop can call
+  `explore` (read-only investigation) and `review` (independent
+  verification) as tools — one coherent thread, specialists when they
+  earn their keep.
+- **Session isolation.** `/isolate` runs the session in its own git
+  worktree; `/review` shows the diff, `/merge` or `/discard` ends it.
+  Auto-checkpoints before every edit; `/undo` restores.
+- **Gets sharper at your repo.** A per-project notebook plus episode
+  memory (`.loom/`) — notes the agent used get credited when a turn
+  goes well, so future runs surface what worked. `/good` and `/bad`
+  train it.
+- **Cost you can see.** Every response closes with that turn's tokens
+  and dollar cost (`free` on free tiers). `/cost` has session totals.
+- **MCP out of the box.** Connect Linear, Sentry, Postgres,
+  Playwright, or any MCP server; `/mcp` lists what's live.
+- **Goal mode.** `/goal make all tests pass` keeps working until the
+  condition is verifiably met.
+
+## Install
+
+```bash
+pipx install git+https://github.com/Anurich/loomflow-cli
+```
+
+(`pip install` works too; `pipx` keeps CLI tools in their own venvs.
+No pipx? `brew install pipx` or `python -m pip install --user pipx`.)
+
+Requires Python 3.11+. To update: `pipx upgrade loom-code`.
+
+## Quickstart
+
+```bash
+cd ~/your-project
+loom-code
+```
+
+First run: type `/set_model`, pick a provider with the arrow keys,
+paste your API key once (it's saved for future sessions), pick a
+model. **No paid key?** Pick NVIDIA — free at
+[build.nvidia.com](https://build.nvidia.com).
+
+Then just type what you want:
+
+```
+›  fix the failing test in tests/test_auth.py
+›  add a /users endpoint with pagination
+›  why is startup slow? profile it
+```
+
+One-shot mode (does the task, prints a summary, exits):
+
+```bash
+loom-code "add a retry decorator to the http client"
+loom-code --yes "scaffold a FastAPI backend"   # skip approval prompts
+```
+
+Works on existing code and empty directories alike — scaffolding new
+projects is a first-class path.
+
+## Models
+
+| model string | provider | env key |
+|---|---|---|
+| `claude-opus-4-8`, `claude-sonnet-4-6`, … | Anthropic | `ANTHROPIC_API_KEY` |
+| `gpt-4.1`, `gpt-4.1-mini`, `o4-mini`, … | OpenAI | `OPENAI_API_KEY` |
+| `nvidia/…` (Nemotron, Llama, DeepSeek) | NVIDIA NIM — **free tier** | `NVIDIA_NIM_API_KEY` |
+| `ollama/llama3`, `ollama/qwen2.5-coder`, … | local [Ollama](https://ollama.com) — free, offline | — |
+| `litellm/<provider>/<model>` | anything LiteLLM routes | provider's own |
+
+Switch anytime with `/model <name>` or the guided `/set_model`.
+Reasoning models support `/effort low|medium|high`.
+
+> Tip: tool-heavy agent work needs a model with solid function
+> calling. On the free NVIDIA tier, `deepseek-v4-pro` and
+> `nemotron-super-49b` hold up well; tiny models fumble tool calls.
+
+## Safety & permissions
+
+The permission layer is the boundary, not the working directory:
+
+- **Reads** anywhere are allowed; **writes outside the project** are
+  only possible for files *you* referenced, and always show a diff
+  prompt — in every mode, even `--yes`.
+- **Approval modes** (`/mode`): `default` asks for writes and shell;
+  `accept-edits` auto-approves in-project edits; `plan` is read-only;
+  `yolo` approves everything except your deny rules.
+- **Rules** live in `.loom/settings.toml` — glob-based
+  `allow` / `ask` / `deny` per tool (e.g. `deny = ["edit(*.env)"]`).
+  Deny always wins, even in yolo.
+- **Sandbox**: `--sandbox` runs bash under OS-level isolation
+  (writes limited to the repo, network off unless
+  `--sandbox-allow-network`).
+- Irreversible commands (`git push --force`, `rm -rf`, …) always
+  get an explicit prompt.
+
+## Commands
+
+Type `/` in the REPL — the menu autocompletes. Highlights:
+
+| | |
+|---|---|
+| `/plan` | show or start the living plan |
+| `/goal <condition>` | work until the condition is met |
+| `/undo` · `/checkpoints` | restore / list auto-checkpoints |
+| `/isolate` · `/review` · `/merge` · `/discard` | worktree-isolated sessions |
+| `/model` · `/set_model` · `/effort` · `/mode` | model + approval setup |
+| `/set_web` | web search (Serper / DuckDuckGo) |
+| `/mcp` | list connected MCP servers |
+| `/cost` · `/compact` · `/export` | session accounting + history |
+| `/resume` | pick up the last session for this project |
+| `/good` · `/bad` | credit / debit the agent's notes |
+
+## Project context
+
+loom-code reads `LOOM.md` / `CLAUDE.md` / `AGENTS.md` /
+`.loom/context.md` at the project root and treats it as binding house
+rules. `/init-loom` creates a starter file.
+
+## Development
+
+```bash
+git clone https://github.com/Anurich/loomflow-cli
+cd loomflow-cli
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest -q          # 465 tests
+ruff check .
+```
+
+Architecture in one line: **loom-code is deliberately thin** — if a
+capability belongs in the agent loop, it goes in
+[loomflow](https://github.com/Anurich/LoomFlow), not here. See
+`DESIGN.md` for the boundary.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

loom_code-0.1.1.dist-info/RECORD

@@ -0,0 +1,58 @@
+loom_code/__init__.py,sha256=am0nt0omKYSWlzGtoVZC2JScZoNy1ncT2SCCIraw5XY,949
+loom_code/_post_commit.py,sha256=wM1E9T-52dXbTF_eHzb6Ve_F02yPTOU1OXGUf1C7hu4,4239
+loom_code/agent.py,sha256=DslJCjfO1P5LrMVBFjCjTrebB1_AMM3GxDuqqrDMjVU,24809
+loom_code/approval.py,sha256=2lNZC4inyF_qggySVxlnJVlZwQgM9GGHFHyWR0E547k,22791
+loom_code/checkpoint.py,sha256=9lCSo88PVfK9_KquX6EqO5nQbIuDdM5Ip2asTNHFDng,10282
+loom_code/cli.py,sha256=GPy5nrXnShfgMtEg0JG7dBn6UCiVhVzPAZ1CKQomic0,17570
+loom_code/code_index.py,sha256=nlUfIXKZ6xMRoMPGl_Scu93i52OZSapBI3_BGqYYMD4,27553
+loom_code/compact.py,sha256=45-iCdMAJ5wcX6lWab8_NZZ_z3VfJO3mAZwNHFsAyUY,5456
+loom_code/consent.py,sha256=Qnyo6TymAmOUxv8JAdv3Px74CJvcF_dXv0xUb3vuGOQ,1721
+loom_code/credentials.py,sha256=0cUjElx6hLBYieeucqzlZAe_ey-nMXpJw1K17nljOn8,21404
+loom_code/edit_tool.py,sha256=34cB9TRpTSfMnD7vFX5kMCrJ9i4SPbUoMOBBEOtmDio,25703
+loom_code/extensions.py,sha256=ClCbZ-anomkTKXUMDrpBdZRp4t07eBXv4zvR8XEPO7A,19031
+loom_code/file_history.py,sha256=6MRi6khIVLt-oF6F4M4OgtaIhPpWs6MeC4GOz0AfAoI,11574
+loom_code/file_tools.py,sha256=08c1jrc9nDxL_jgvWInO-uqhXOscY6exZdUwzBFVGK0,4016
+loom_code/git_hook.py,sha256=gx556a385-dEsctz-HqBj4m-3273PIUT-48x8puH8mM,7415
+loom_code/grep_tool.py,sha256=wtQYRkE6OpY_EeUdd8geLuj4MWt8C2iKFv96ZqLjat0,16593
+loom_code/hooks.py,sha256=x-LX92jOn--uBmDPNcsW1K1h5nqxAGJrfDQZH6FXPow,10992
+loom_code/lsp_tools.py,sha256=R73TSwRs9ZgiKgfJ5xP4sUiBvm5tYlyJjDZhJ8Qq8ss,14739
+loom_code/mcp_host.py,sha256=a-JrPfJKE7s8YuZJFNIAGoH73UwUdFT8zzGtNe0YepU,3165
+loom_code/operator.py,sha256=Qbhnz8CSdZBGi-7DGggP1xbOy4n_8Fd0qqy20vLs3Kc,20773
+loom_code/paste.py,sha256=o7Zq70aCU6HQB6Gziez8jNP8KBVBTbnqAIfeVOnXFww,3437
+loom_code/paths.py,sha256=HHFbDkpXgIQWND1XGWSao_9RVpF9HyZ2fCEpOWDcY2E,2044
+loom_code/permissions.py,sha256=RkxqiHu1eqwaVyaLGHinW4amz69S9i8zC9lW0OTH1h8,6314
+loom_code/project.py,sha256=iEUQOYUA23d06ZlaAcNouei635t5K-B_E-Ri0DPZEB0,3639
+loom_code/prompts.py,sha256=i0NoblhIk58UhQTkHuOFi3yqenDs9C60KpFPLP-P7iQ,21892
+loom_code/render.py,sha256=6fuGpC74WBAw-31qrqwa5XEfMVw_ZZqYEI0eqJ9jYm0,33756
+loom_code/repl.py,sha256=Tja7idGyeAOOsdAmLkTA0wVbKSwBQieGhPyEUe4Emkw,174054
+loom_code/rules.py,sha256=pdy1t8L7ic9nE5bSJPs_FoHxfKdhK0A6-c8JIws7ZMM,9778
+loom_code/sandboxed_bash.py,sha256=kfDfKwgTj7MUjUPutxRUykytjgY8qOjih2OZlRnL88g,6438
+loom_code/scribe.py,sha256=Lz4pT4Xu9RquoQafgaOmkIaodFI252Dttr_6ycKgmMI,3145
+loom_code/trust.py,sha256=Eimvs0OwE9rr8Ve3c3if4wiQaRB6kfgIi0XA_23Hmsc,7655
+loom_code/turn.py,sha256=vl3dZkFVAoiBYpAfsXB5RUSjFcuqHTpxgzwK0MWV1nE,5773
+loom_code/web_fetch.py,sha256=IfMua8sTmCB61T0gpWxe3oC1yst0Ul4tEXmzy1rIaZU,15386
+loom_code/workers.py,sha256=e_mZx-bg5M6g4vEnGxgReJiDivGLYqa_cSZ7Opa4s9w,31333
+loom_code/worktree.py,sha256=CKbiYAvVd6OS3eX89NIeB2KJ1O_rNfUlIuLNu1uZXO8,4782
+loom_code/browse/__init__.py,sha256=nYi8jQBzLGDCZb0W0s6IYX4EV0K2pgJTz304j6tdk2s,12741
+loom_code/browse/act.py,sha256=5h3DeBKJkDbUjniXPBSbqq1vEg23QRlwGwi8HpBtKSM,17015
+loom_code/browse/observe.py,sha256=PJi6OmrIX93MO1Ri5R9qp5kFjs6RhKJmpF5beE0il6E,9337
+loom_code/browse/session.py,sha256=RNPA39oNrhYN_ZTK1dIl2hGL3BNSDkvRI6dmD3jhb-g,3778
+loom_code/browse/verify.py,sha256=zuJhy17BR6iLPu2EZ0bqklxIV72NCrJQY9EHsOj1zG4,7660
+loom_code/loominit/__init__.py,sha256=R4UDbwhmwAOg9QD24zbxeqG4vbdIIrfsFST9FxSzgrM,1166
+loom_code/loominit/_ast_walk.py,sha256=4iSF0SUxSp3gDGVqqeB8TyDrOes3SaLpUu6554qcHTA,15784
+loom_code/loominit/_files.py,sha256=CQWiMf25RRWrePpHlAkwbz95T1T7xJ9bz7hojA0mcTY,9212
+loom_code/loominit/_graph.py,sha256=vtZBdIEyFeXjf9XLrnS0l2p0lMqw09os4_5MMFnmHfA,5184
+loom_code/loominit/_resolve.py,sha256=f-zPHDvSAEn5uw30I9UEIE-OMYo1UYPKWSPlJHqQiFc,14035
+loom_code/loominit/_tests_map.py,sha256=Na6bfsj5gpG-_y1_jT0smRIvs7i3LeSrs_c6e-UkJiI,3604
+loom_code/loominit/extractor.py,sha256=WmMEXAVadPw6vYIB0PiBZwofr_x647T8GFfMP1CzYZY,11803
+loom_code/loominit/repomap.py,sha256=gyyDgfMmo8mNNwWsj4aZPLJxJfJSkz-P65ijluM6C1s,8307
+loom_code/loominit/schema.py,sha256=WVHREn_xXjGtafmMBPkQUeeSFplnkj0ZNTTzw37gl70,9037
+loom_code/skills/__init__.py,sha256=_CeYfPjc82C6AXOIJ8gvhdB-2YbYqx9OwPoZ0_k1U9A,641
+loom_code/skills/graphify/SKILL.md,sha256=sCsZ_J3i1mSCM6IV_WsYVu84LbYOXXbQmF5hy5alSPg,4424
+loom_code/skills/graphify/tools.py,sha256=67LVXOzYE2cM3T061xxuQaQLDXjR810GX_wMoUG1hUM,23316
+loom_code-0.1.1.dist-info/licenses/LICENSE,sha256=Qw2tq9Jw4fNrucoVwMew3TJv281S77WxU4pWvlf9YUk,1072
+loom_code-0.1.1.dist-info/METADATA,sha256=xoztBTcjQiIjfs5qT1fxmVgZnfG_1yKjkVGGAapLq4o,9062
+loom_code-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+loom_code-0.1.1.dist-info/entry_points.txt,sha256=yRqKU6PZCzbkM3bdbNK3uLEzjkIhTTP3YO5I30H3cPY,49
+loom_code-0.1.1.dist-info/top_level.txt,sha256=scpQuHtufFFRPlPQjrCqkCPWpH-vdjlwZ_H6pH_AbvE,10
+loom_code-0.1.1.dist-info/RECORD,,

loom_code-0.1.1.dist-info/WHEEL

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

loom_code-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+loom-code = loom_code.cli:main

loom_code-0.1.1.dist-info/licenses/LICENSE

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

loom_code-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+loom_code