tapestry-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{tapestry_cli-0.1.2 → tapestry_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tapestry-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Tapestry command-line interface — onboard projects, inspect state, open the Observatory.
 Author: Liz Osborn
 License: MIT

{tapestry_cli-0.1.2 → tapestry_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tapestry-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "Tapestry command-line interface — onboard projects, inspect state, open the Observatory."
 readme = "README.md"
 requires-python = ">=3.10"

tapestry_cli-0.1.4/tapestry_cli/__init__.py

@@ -0,0 +1,17 @@
+"""tapestry-cli — command-line interface for Tapestry.
+
+Stdlib-only. Cross-platform. Subcommands:
+  tapestry init    — onboard the current directory as a Tapestry consuming project
+  tapestry version — print version + diagnostic info
+
+(`loom` remains a deprecated command alias; see [project.scripts] in pyproject.)
+"""
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _pkg_version
+
+try:
+    # Authoritative source: the installed package's own metadata, so this can
+    # never drift from pyproject again (the 0.1.0-vs-0.1.3 bug it replaces).
+    __version__ = _pkg_version("tapestry-cli")
+except PackageNotFoundError:  # running from a source checkout, not pip-installed
+    __version__ = "0.1.4"

{tapestry_cli-0.1.2 → tapestry_cli-0.1.4}/tapestry_cli/cli.py

@@ -20,6 +20,7 @@ import sys
 from tapestry_cli import (
     __version__,
     init as init_cmd,
+    make_plugin as make_plugin_cmd,
     observatory as observatory_cmd,
     onboard as onboard_cmd,
 )
@@ -41,6 +42,11 @@ SUBCOMMANDS: dict[str, dict] = {
         "add_arguments": init_cmd.add_arguments,
         "run": init_cmd.run,
     },
+    "make-plugin": {
+        "help": "Scaffold a personalized Claude Code plugin to publish to your own marketplace.",
+        "add_arguments": make_plugin_cmd.add_arguments,
+        "run": make_plugin_cmd.run,
+    },
 }
 
 

{tapestry_cli-0.1.2 → tapestry_cli-0.1.4}/tapestry_cli/init.py

@@ -237,9 +237,14 @@ def _write_mcp_config(project_dir: Path) -> None:
     provides memory access.
     """
     mcp_path = project_dir / ".mcp.json"
+    # Mode-agnostic auth header: references the shared-secret env var by name.
+    # When TAPESTRY_MEMORY_API_KEY is unset the client sends "Bearer " (empty),
+    # which the memory server treats as anonymous — so this config is valid both
+    # before the credential exists and after, and needs no change at flip time.
     loom_memory_entry = {
         "type": "http",
         "url": LOOM_MEMORY_MCP_URL,
+        "headers": {"Authorization": "Bearer ${TAPESTRY_MEMORY_API_KEY}"},
     }
 
     if mcp_path.exists():

tapestry_cli-0.1.4/tapestry_cli/make_plugin.py

@@ -0,0 +1,286 @@
+"""`tapestry make-plugin <name>` — scaffold a personalized Claude Code plugin.
+
+Emits a self-contained plugin + single-plugin marketplace that the operator
+publishes to THEIR OWN GitHub repo and points at THEIR OWN backend. Nothing
+personal to anyone else is baked in: the memory endpoint is env-driven with a
+placeholder fallback, and the author is the operator.
+
+The universal `tapestry-discipline` plugin is the always-on baseline (PROBE
+reminders, citation, audit — no backend). This scaffold is the project-specific
+layer: a behavior-only PreToolUse guard to customize for the project's shape,
+plus an optional env-gated memory wiring. See the `plugin-authoring` skill in
+tapestry-patterns for the full author-and-publish workflow.
+
+Stdlib-only.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+from pathlib import Path
+
+# The node launcher is generic (finds Python, runs scripts/<name>.py, passes
+# stdin, propagates exit code). Reused verbatim from the universal plugin.
+_RUN_PYTHON_MJS = r'''#!/usr/bin/env node
+/**
+ * run-python.mjs — Node launcher for the Python hook scripts.
+ * Claude Code guarantees Node on PATH but not Python; this finds Python and
+ * invokes scripts/<name>.py, piping stdin through and propagating exit codes.
+ *   node "${CLAUDE_PLUGIN_ROOT}/hooks/run-python.mjs" <script_basename>
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || dirname(__dirname);
+const scriptName = process.argv[2];
+if (!scriptName) { console.error("run-python.mjs: missing script name"); process.exit(0); }
+const pythonScript = join(pluginRoot, "scripts", `${scriptName}.py`);
+if (!existsSync(pythonScript)) { console.error(`run-python.mjs: not found: ${pythonScript}`); process.exit(0); }
+
+const isWindows = process.platform === "win32";
+const candidates = isWindows
+  ? [["py", ["-3", pythonScript]], ["python", [pythonScript]], ["python3", [pythonScript]]]
+  : [["python3", [pythonScript]], ["python", [pythonScript]]];
+
+let stdinBuf = Buffer.alloc(0);
+try { const fs = await import("node:fs"); stdinBuf = fs.readFileSync(0); } catch {}
+
+let lastExitCode = 0, invoked = false;
+for (const [cmd, args] of candidates) {
+  try {
+    const result = spawnSync(cmd, args, { input: stdinBuf, stdio: ["pipe", "inherit", "inherit"] });
+    if (result.error && result.error.code === "ENOENT") continue;
+    invoked = true; lastExitCode = result.status ?? 0; break;
+  } catch { continue; }
+}
+if (!invoked) { console.error("run-python.mjs: no Python on PATH; hook skipped, not blocking."); process.exit(0); }
+process.exit(lastExitCode);
+'''
+
+_HOOKS_JSON = {
+    "hooks": {
+        "PreToolUse": [
+            {
+                "matcher": "Edit|Write|MultiEdit",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": 'node "${CLAUDE_PLUGIN_ROOT}/hooks/run-python.mjs" pre_tool_use',
+                        "timeout": 10,
+                    }
+                ],
+            }
+        ]
+    }
+}
+
+
+def _pre_tool_use_py(name: str) -> str:
+    return f'''"""{name} — PreToolUse guard (behavior-only, no backend calls).
+
+Customize the checks below for THIS project's shape. Emits a soft reminder via
+additionalContext; never blocks by default (exit 0). Exit 2 to block a tool
+call (Claude Code hook protocol). Keep it behavior-only so it works for any
+operator with no backend configured.
+"""
+import json
+import sys
+
+
+def main() -> int:
+    try:
+        data = json.load(sys.stdin)
+    except Exception:  # never raise from a hook
+        return 0
+
+    # TODO: add project-specific guards here. Example checks you might add:
+    #   - warn when editing a load-bearing file
+    #   - require a test alongside a source change
+    #   - block edits to a generated/vendored directory (return exit 2)
+    _tool = data.get("tool_name", "")
+
+    reminder = (
+        "[{name}] PROBE before editing: confirm the change matches this "
+        "project's conventions; cite file:line for any pattern you copy."
+    ).format(name="{name}")
+
+    print(json.dumps({{
+        "hookSpecificOutput": {{
+            "hookEventName": "PreToolUse",
+            "additionalContext": reminder,
+        }}
+    }}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+'''.replace("{name}", name)
+
+
+def _plugin_json(name: str, author: str) -> dict:
+    return {
+        "name": name,
+        "description": (
+            f"Personalized Tapestry discipline plugin for {name}. Project-specific "
+            "guards plus this operator's own backend. The universal "
+            "tapestry-discipline plugin is the always-on baseline; this is the "
+            "project layer. Generated by `tapestry make-plugin`."
+        ),
+        "version": "0.1.0",
+        "author": {"name": author},
+        "license": "Apache-2.0",
+        "keywords": ["tapestry", "discipline", "personalized"],
+        # Env-driven, placeholder fallback — point at YOUR own memory backend.
+        "mcpServers": {
+            "loom-memory": {
+                "type": "http",
+                "url": "${LOOM_MEMORY_MCP_URL:-https://your-memory-host.example.com/mcp/memory/}",
+            }
+        },
+    }
+
+
+def _marketplace_json(name: str, author: str) -> dict:
+    return {
+        "$schema": "https://json.schemastore.org/claude-code-marketplace.json",
+        "name": name,
+        "description": f"{author}'s plugin marketplace.",
+        "owner": {"name": author},
+        "plugins": [
+            {
+                "name": name,
+                "source": "./",
+                "description": "Personalized Tapestry discipline plugin.",
+            }
+        ],
+    }
+
+
+def _readme(name: str, login: str) -> str:
+    repo = f"{login}/{name}" if login else f"<your-github>/{name}"
+    return f'''# {name}
+
+A personalized Claude Code discipline plugin, generated by `tapestry make-plugin`.
+
+The universal `tapestry-discipline` plugin is the always-on baseline. This plugin
+is the project-specific layer: customize `scripts/pre_tool_use.py` with guards for
+this project's shape, and point `mcpServers.loom-memory` at YOUR own backend via
+the `LOOM_MEMORY_MCP_URL` env var (it defaults to a placeholder).
+
+## Test locally
+Enable it in `.claude/settings.json` (or `/plugin marketplace add` from this dir),
+then trigger an edit and confirm the PreToolUse reminder fires. With no backend
+configured it stays behavior-only — that's expected.
+
+## Publish to your own marketplace
+```bash
+gh repo create {repo} --public --source . --push
+```
+Then in Claude Code:
+```text
+/plugin marketplace add {repo}
+/plugin install {name}@{name}
+```
+
+Set your backend (optional, for memory):
+```bash
+export LOOM_MEMORY_MCP_URL=https://<your-memory-host>/mcp/memory/
+```
+'''
+
+
+def _slug(s: str) -> str:
+    s = re.sub(r"[^a-zA-Z0-9._-]+", "-", s.strip()).strip("-").lower()
+    return s or "my-plugin"
+
+
+def _git_author() -> str:
+    try:
+        out = subprocess.run(
+            ["git", "config", "user.name"],
+            capture_output=True, text=True, timeout=3,
+        )
+        if out.returncode == 0 and out.stdout.strip():
+            return out.stdout.strip()
+    except (subprocess.SubprocessError, OSError):
+        pass
+    return "Your Name"
+
+
+def _gh_login() -> str:
+    try:
+        out = subprocess.run(
+            ["gh", "api", "user", "-q", ".login"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if out.returncode == 0 and out.stdout.strip():
+            return out.stdout.strip()
+    except (subprocess.SubprocessError, OSError):
+        pass
+    return ""
+
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("name", help="Plugin name (kebab-case, e.g. my-project-guard).")
+    parser.add_argument(
+        "--dir", default=".",
+        help="Parent directory to create the plugin in (default: current dir).",
+    )
+    parser.add_argument(
+        "--author", default=None,
+        help="Author name (default: git config user.name).",
+    )
+    parser.add_argument(
+        "--dry-run", dest="dry_run", action="store_true",
+        help="Print the files that would be created without writing them.",
+    )
+
+
+def run(args: argparse.Namespace) -> int:
+    name = _slug(args.name)
+    author = args.author or _git_author()
+    login = _gh_login()
+    root = Path(args.dir).resolve() / name
+
+    files = {
+        ".claude-plugin/plugin.json": json.dumps(_plugin_json(name, author), indent=2) + "\n",
+        ".claude-plugin/marketplace.json": json.dumps(_marketplace_json(name, author), indent=2) + "\n",
+        "hooks/hooks.json": json.dumps(_HOOKS_JSON, indent=2) + "\n",
+        "hooks/run-python.mjs": _RUN_PYTHON_MJS,
+        "scripts/pre_tool_use.py": _pre_tool_use_py(name),
+        "README.md": _readme(name, login),
+    }
+
+    if args.dry_run:
+        print(f"Would create plugin '{name}' (author: {author}) at {root}:")
+        for rel in files:
+            print(f"  {root / rel}")
+        return 0
+
+    if root.exists():
+        print(f"Refusing to overwrite existing directory: {root}")
+        return 1
+
+    for rel, content in files.items():
+        dest = root / rel
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(content, encoding="utf-8")
+
+    print(f"Created plugin '{name}' (author: {author}) at {root}")
+    print("  .claude-plugin/plugin.json   — env-driven memory URL (set LOOM_MEMORY_MCP_URL)")
+    print("  .claude-plugin/marketplace.json")
+    print("  hooks/hooks.json + hooks/run-python.mjs")
+    print("  scripts/pre_tool_use.py      — customize guards for this project")
+    print("  README.md                    — how to test + publish")
+    print()
+    print("Next: customize scripts/pre_tool_use.py, then publish to your own marketplace:")
+    repo = f"{login}/{name}" if login else "<your-github>/" + name
+    print(f"  gh repo create {repo} --public --source {root} --push")
+    print(f"  /plugin marketplace add {repo}")
+    return 0

{tapestry_cli-0.1.2 → tapestry_cli-0.1.4}/tapestry_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tapestry-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Tapestry command-line interface — onboard projects, inspect state, open the Observatory.
 Author: Liz Osborn
 License: MIT

{tapestry_cli-0.1.2 → tapestry_cli-0.1.4}/tapestry_cli.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ tapestry_cli/__init__.py
 tapestry_cli/__main__.py
 tapestry_cli/cli.py
 tapestry_cli/init.py
+tapestry_cli/make_plugin.py
 tapestry_cli/observatory.py
 tapestry_cli/onboard.py
 tapestry_cli.egg-info/PKG-INFO

tapestry_cli-0.1.2/tapestry_cli/__init__.py

@@ -1,7 +0,0 @@
-"""tapestry-cli — command-line interface for the-loom.
-
-Stdlib-only. Cross-platform. Subcommands:
-  loom init    — onboard the current directory as a loom consuming project
-  loom version — print version + diagnostic info
-"""
-__version__ = "0.1.0"