@fradser/pi-context 0.5.0 → 0.5.1

package/README.md

@@ -1,16 +1,32 @@
-# Code Context Pi Package
+# Context Pi Package
 
-**Version:** 0.4.1
+**Version:** 0.5.0
 
 Retrieve code context for any repo, library, or natural-language query via 5 methods: DeepWiki, Context7, Exa, git clone, and web search+fetch.
 
+The package does **not** ship a skill. Native tool guidance is injected into the system prompt, and the `/context` command loads the full workflow into the current turn.
+
 ## Installation
 
 ```bash
-pi install /path/to/pi-packages/packages/code-context
+pi install npm:@fradser/pi-context
+# or from this repository:
+pi install /path/to/pi-packages/packages/context
+```
+
+## Usage
+
+Run `/context` followed by a natural-language question, repository slug, library name, or several targets. For example:
+
+```text
+/context React 19 server actions error handling
+/context facebook/react
+/context facebook/react zustand --method=deepwiki,context7
 ```
 
-Run `/skill:get-context <query…>` for the executable Pi workflow.
+`--method=` accepts `deepwiki,context7,exa,clone,web,all` (comma-separated). With no target, the command reads dependency manifests in the current directory (`package.json`, `pyproject.toml`, `go.mod`, `Cargo.toml`) and uses detected dependencies as targets.
+
+The full workflow (target classification, per-method process, fallbacks, selection guide) lives in `references/workflow.md` and is injected into the turn when `/context` runs. Lightweight tool-selection guidance is always present in the system prompt.
 
 ## Runtime requirements
 
@@ -22,161 +38,49 @@ Run `/skill:get-context <query…>` for the executable Pi workflow.
 | Git clone | Always | Pi `bash` + `read` |
 | Web fetch | Always | `curl`/HTTP via `bash` |
 
-All three retrieval tools are registered by this package's extension (`extensions/context-tools.ts`) and call the public REST APIs directly — no MCP servers needed.
-
-## Overview
-
-Code Context accepts **arbitrary input** — a natural-language question, a repo slug, a library name, or several of these at once — and routes each target to the right method(s). It prefers intermediate summaries so the main conversation stays clean, returning only synthesized summaries.
-
-## Methods
-
-### 1. DeepWiki (AI-powered repo documentation)
-
-Best for: Public GitHub repositories requiring architecture overview, component explanations, or high-level understanding.
-
-**Tool:** `context_deepwiki` — `owner`/`repo` + `mode: structure | contents | ask`
-
-**Process:**
-1. `context_deepwiki` with `mode: "structure"` (e.g. owner=`facebook`, repo=`react`)
-2. `context_deepwiki` with `mode: "contents"` for full wiki text, or `mode: "ask"` + `question` for targeted Q&A
-
-**Strengths:** Zero setup, instant AI-summarized documentation.
-
-**Limitations:** Only works for public GitHub repos; coverage varies by popularity.
-
----
-
-### 2. Context7 (library documentation)
-
-Best for: Getting up-to-date API docs, usage examples, and version-specific documentation for npm/pip packages.
-
-**Tool:** `context_context7` — `query` + optional `topic`
-
-**Process:**
-1. `context_context7` with the library name (e.g. `"react"`, `"fastapi"`)
-2. Pass a `topic` (e.g. `"auth"`, `"ssr"`) for focused snippets; include the version in the query when given (`react@18`)
-
-**Strengths:** Always current docs, supports version pinning, covers thousands of libraries.
-
-**Limitations:** Requires the library to be indexed; less useful for internal packages.
-
----
-
-### 3. Exa Code Search (web-wide code examples)
-
-Best for: Finding real-world usage patterns, StackOverflow answers, GitHub Gist examples.
-
-**Tool:** `context_exa` — `query` + optional `numResults` (requires `EXA_API_KEY`)
-
-**Query tips:**
-- Include language: `"TypeScript React"`
-- Include version: `"Next.js 14 app router"`
-- Use exact identifiers: `"useServerAction"`
-- Add pattern type: `"example"`, `"error handling"`
-
-**Strengths:** Finds diverse real-world examples beyond official docs.
-
-**Limitations:** Results may be outdated; verify publication dates.
-
----
-
-### 4. Git Clone (direct code inspection)
-
-Best for: Private repositories, detailed implementation review, or when other methods lack depth.
-
-**Process:**
-1. `git clone <repo-url> /tmp/<repo-name> --depth=1`
-2. Read key files: entry points, configuration, core modules
-3. Use bash find/grep and Pi `read` to analyze structure and patterns
-4. Clean up: `rm -rf /tmp/<repo-name>`
-
-**Strengths:** Full code access, works with private repos.
-
-**Limitations:** Requires network/disk space; slow for large repos.
-
----
-
-### 5. Web Search + Fetch (post-clone enrichment)
-
-Best for: Enriching clone findings with changelogs, issue discussions, migration guides.
-
-**Tools:** web search via `curl`/HTTP, HTTP fetch via `curl`
-
-**When to use:** After completing Method 4. Gives you the *why* and *what changed*.
-
-**Query patterns:**
-- Changelogs: `"<repo> CHANGELOG v<version>"`
-- Design rationale: `"<repo> <concept> why OR rationale site:github.com"`
-- Migration: `"<repo> migrate from <old> to <new>"`
-
-**Strengths:** Surfaces context never in source code.
-
-**Limitations:** Results may be stale; always validate against actual code.
-
----
-
-## Usage
-
-### Pi skill: get-context
-
-Run `/skill:get-context` followed by a natural-language question, repository slug, library name, or several targets. For example:
-
-```text
-/skill:get-context React 19 server actions error handling
-/skill:get-context facebook/react
-/skill:get-context facebook/react zustand --method=deepwiki,context7
-```
-
-`--method=` accepts `deepwiki,context7,exa,clone,web,all` (comma-separated). With no target, the skill reads dependency manifests in the current directory. It classifies each target and routes it through the allowed methods, noting gaps when a permitted method cannot cover it.
+All three retrieval tools are registered by this package's root extension entry (`index.ts`) and call the public REST APIs directly — no MCP servers needed.
 
-### Optional manual brief
+## Methods (summary)
 
-`agents/context-researcher.md` is an optional manual prompt brief for an isolated research pass. Pi does not load it as an invocable agent; use the `get-context` skill for the executable workflow.
+1. **DeepWiki** — AI-generated repo docs via `context_deepwiki` (`mode: structure | contents | ask`).
+2. **Context7** — up-to-date library docs via `context_context7` (`query` + optional `topic`).
+3. **Exa** — web/code search via `context_exa` (`query` + optional `numResults`, requires `EXA_API_KEY`).
+4. **Git clone** — `git clone --depth=1` to `/tmp`, `read` key files, clean up.
+5. **Web search+fetch** — `bash` + `curl` against official docs, GitHub issues, changelogs.
 
-The package's internal method-selection guidance is loaded by the `get-context` workflow.
+If a native tool is unavailable or errors, fall back to clone/web. The `/context` workflow reference contains the full selection matrix and per-method process.
 
-## Method Selection Guide
+## Optional manual brief
 
-| Scenario | Primary | Fallback |
-|----------|---------|----------|
-| "How does X library work?" | Context7 | DeepWiki |
-| "Understand Y repo architecture" | DeepWiki | Git Clone |
-| "Find examples of Z pattern" | Exa | Context7 |
-| "Inspect private/internal repo" | Git Clone | - |
-| "What changed in v3?" | Context7 | Exa |
-| "How are modules connected?" | DeepWiki | Git Clone |
-| "Why was this design decision?" | Git Clone → Web Search | DeepWiki |
-| "Compare X vs Y" (natural-language) | Exa + Context7 | Web Search |
-| "Best practice for Z" (natural-language) | Web Search | Exa |
+`agents/context-researcher.md` is an optional manual prompt brief for an isolated research pass. Pi does not load it as an invocable agent; use the `/context` command for the executable workflow.
 
 ## Structure
 
 ```
-code-context/
+context/
+├── index.ts                     # Package-root extension entry point
 ├── extensions/
-│   └── context-tools.ts         # Native pi tools: context_deepwiki / context_context7 / context_exa
+│   ├── context-tools.ts         # Native pi tools: context_deepwiki / context_context7 / context_exa
+│   └── context-command.ts       # /context command + system-prompt guidance
+├── references/
+│   └── workflow.md              # Full workflow injected by /context
 ├── agents/
-│   └── context-researcher.md    # Isolated research agent brief
-├── skills/
-│   ├── code-context/            # Knowledge skill (internal)
-│   │   └── SKILL.md            # Method selection guide
-│   └── get-context/             # User-invocable command
-│       └── SKILL.md            # Command workflow
+│   └── context-researcher.md    # Isolated research brief (manual)
 └── README.md
 ```
 
 ## Prerequisites
 
-- Pi 0.84+ (extensions + custom tools)
+- Pi with extensions + custom tools
 - Network access for external lookups
 - `EXA_API_KEY` for the Exa method (optional for the other four)
 
 ## Best Practices
 
-- **Local first**: Always check local context (package.json, imports) before external lookups
-- **Isolated execution**: External lookups run in agent context to keep main conversation clean
-- **Combine methods**: For comprehensive context, use DeepWiki → Context7 → Exa → Clone
-- **Verify sources**: Cross-reference fetched content against actual code
+- **Local first**: check local context (package.json, imports) before external lookups.
+- **Combine methods**: DeepWiki / clone for architecture, Context7 for API surface, Exa / web for community patterns.
+- **Verify sources**: cross-reference fetched content against actual code.
+- **Clean up**: remove `/tmp` clones when finished.
 
 ## License
 

package/agents/context-researcher.md

@@ -5,7 +5,7 @@ description: Research a library, repository, or code pattern without polluting t
 
 # Context researcher (optional agent brief)
 
-Pi does not load Claude Code agent files automatically. Treat this file as a **prompt brief** when you want an isolated research pass. Prefer `/skill:get-context` or `/skill:code-context` for the executable workflow.
+Pi does not load Claude Code agent files automatically. Treat this file as a **prompt brief** when you want an isolated research pass. Prefer the `/context` command for the executable workflow.
 
 ## Runtime requirements
 
@@ -21,9 +21,9 @@ If a native context tool is unavailable or fails, skip that method, use clone +
 
 ## Process
 
-1. **Parse the request** — targets and optional `--method=` list (see `/skill:get-context`).
+1. **Parse the request** — targets and optional `--method=` list (see `/context`).
 2. **Classify** each target (repo / library / natural-language).
-3. **Select methods** per `/skill:code-context` selection guide.
+3. **Select methods** per the `/context` workflow's selection guide.
 4. **Execute with Pi tools** — use the applicable native context tools (`context_deepwiki`, `context_context7`, `context_exa`) plus `bash` and `read`. Summarize intermediates; do not dump raw payloads.
 5. **Return** a concise architecture/API/examples summary only.
 

package/extensions/context-command.ts

@@ -0,0 +1,121 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const PKG_DIR =
+  typeof __dirname === "string"
+    ? __dirname
+    : dirname(fileURLToPath(import.meta.url));
+
+const WORKFLOW_PATH = join(PKG_DIR, "..", "references", "workflow.md");
+
+const METHOD_FLAG = "--method=";
+const ALL_METHODS = ["deepwiki", "context7", "exa", "clone", "web", "all"] as const;
+const MANIFEST_FILES = ["package.json", "pyproject.toml", "go.mod", "Cargo.toml"];
+
+const CONTEXT_GUIDANCE = `
+## Context retrieval
+
+- Use \`context_deepwiki\` for public GitHub repo architecture and DeepWiki Q&A.
+- Use \`context_context7\` for up-to-date library/API docs (optionally focused by topic).
+- Use \`context_exa\` for web/code search when EXA_API_KEY is set; otherwise fall back to \`bash\` + \`curl\`.
+- Use \`git clone --depth=1\` to /tmp plus \`read\`/\`bash\` for private repos or deep inspection; always clean up.
+- Prefer small intermediate summaries over dumping raw API payloads into the conversation.
+- The \`/context <targets...> [--method=...]\` command loads the full workflow when the user asks to research or understand code.
+`;
+
+interface ParsedArgs {
+  targets: string[];
+  methods: string[];
+}
+
+function parseArgs(raw: string): ParsedArgs {
+  const targets: string[] = [];
+  let methods: string[] = ["all"];
+  const tokens = raw.match(/(?:[^\s"]+|"[^"]*")+/g) ?? [];
+  for (const token of tokens) {
+    if (token.startsWith(METHOD_FLAG)) {
+      methods = token
+        .slice(METHOD_FLAG.length)
+        .split(",")
+        .map((m) => m.trim().toLowerCase())
+        .filter((m) => (ALL_METHODS as readonly string[]).includes(m));
+      if (methods.length === 0) methods = ["all"];
+      continue;
+    }
+    targets.push(token.replace(/^"|"$/g, ""));
+  }
+  return { targets, methods };
+}
+
+function detectDependencies(cwd: string): string[] {
+  const deps = new Set<string>();
+  for (const file of MANIFEST_FILES) {
+    try {
+      const text = readFileSync(join(cwd, file), "utf8");
+      if (file === "package.json") {
+        const json = JSON.parse(text) as {
+          dependencies?: Record<string, string>;
+          devDependencies?: Record<string, string>;
+        };
+        for (const name of Object.keys(json.dependencies ?? {})) deps.add(name);
+        for (const name of Object.keys(json.devDependencies ?? {})) deps.add(name);
+      } else if (file === "pyproject.toml") {
+        for (const match of text.matchAll(/^\s*"([A-Za-z0-9_.-]+)"\s*[>=<~!]/gm)) {
+          deps.add(match[1]);
+        }
+      } else if (file === "go.mod") {
+        for (const match of text.matchAll(/^\s*([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)\s+v/gm)) {
+          deps.add(match[1]);
+        }
+      } else if (file === "Cargo.toml") {
+        for (const match of text.matchAll(/^([A-Za-z0-9_-]+)\s*=\s*"[^"]+"/gm)) {
+          deps.add(match[1]);
+        }
+      }
+    } catch {
+      // Missing or unreadable manifest — skip.
+    }
+  }
+  return [...deps];
+}
+
+function loadWorkflow(): string {
+  return readFileSync(WORKFLOW_PATH, "utf8");
+}
+
+function buildUserPrompt(args: ParsedArgs, cwd: string): string {
+  const workflow = loadWorkflow();
+  const targets = args.targets.length > 0 ? args.targets : detectDependencies(cwd);
+  const header = [
+    "Run the /context workflow.",
+    "",
+    `Targets: ${targets.length > 0 ? targets.join(", ") : "(none provided and no dependencies detected in cwd)"}`,
+    `Allowed methods: ${args.methods.join(",")}`,
+    "",
+    "---",
+    "",
+  ].join("\n");
+  return header + workflow;
+}
+
+export function registerContextCommand(pi: ExtensionAPI): void {
+  pi.on("before_agent_start", async (event) => ({
+    systemPrompt: event.systemPrompt + CONTEXT_GUIDANCE,
+  }));
+
+  pi.registerCommand("context", {
+    description:
+      "Retrieve code context for repos, libraries, or a natural-language question via DeepWiki, Context7, Exa, clone, or web.",
+    handler: async (rawArgs, ctx) => {
+      const args = parseArgs(rawArgs.trim());
+      const prompt = buildUserPrompt(args, ctx.cwd);
+      pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+    },
+  });
+}
+
+export default function register(pi: ExtensionAPI): void {
+  registerContextCommand(pi);
+}

package/extensions/context-tools.ts

@@ -122,7 +122,7 @@ const ExaParams = Type.Object({
 	),
 });
 
-export default function (pi: ExtensionAPI) {
+export function registerContextTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "context_deepwiki",
 		label: "DeepWiki repo docs",
@@ -273,3 +273,5 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 }
+
+export default registerContextTools;

package/index.ts

@@ -0,0 +1,8 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import registerContextCommand from "./extensions/context-command.ts";
+import registerContextTools from "./extensions/context-tools.ts";
+
+export default function contextExtension(pi: ExtensionAPI): void {
+  registerContextTools(pi);
+  registerContextCommand(pi);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fradser/pi-context",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Retrieve code context for any repo, library, or natural-language query via DeepWiki, Context7, Exa, git clone, and web search+fetch. Native pi tools (context_deepwiki/context_context7/context_exa) call the public REST APIs directly — no MCP servers.",
   "keywords": [
     "pi-package",
@@ -19,17 +19,15 @@
     "access": "public"
   },
   "files": [
-    "skills",
+    "index.ts",
     "extensions",
+    "references",
     "agents",
     "README.md"
   ],
   "pi": {
-    "skills": [
-      "./skills"
-    ],
     "extensions": [
-      "./extensions"
+      "./index.ts"
     ]
   },
   "peerDependencies": {
@@ -37,4 +35,4 @@
     "@earendil-works/pi-ai": "*",
     "typebox": "*"
   }
-}
+}

package/references/workflow.md

@@ -0,0 +1,108 @@
+# context workflow
+
+Retrieve code context for any repo, library, or natural-language code/technology question. Five methods are available; pick them per target. Prefer small intermediate summaries over dumping raw API payloads into the long-lived conversation.
+
+## Native tools
+
+| Method | Tool | Availability |
+|--------|------|--------------|
+| DeepWiki | `context_deepwiki` | always, no key |
+| Context7 | `context_context7` | always, optional `CONTEXT7_API_KEY` for higher quota |
+| Exa | `context_exa` | requires `EXA_API_KEY` |
+| Git clone | `bash` + `read` | always |
+| Web search+fetch | `bash` + `curl` | always |
+
+If a native tool is unavailable or errors (e.g. `EXA_API_KEY` unset), skip it and use the documented clone/web fallback. Report which methods ran. There are no Pi built-ins named `WebSearch`/`WebFetch`/`Task` — do not invent them.
+
+## Invocation
+
+`/context [targets...] [--method=a,b,...]`
+
+- `--method=` accepts a comma-separated list from `deepwiki,context7,exa,clone,web,all`. Default: `all`.
+- Quoted strings are one target. Multiple positional tokens are multiple targets.
+- No targets: read dependency manifests in cwd (`package.json`, `go.mod`, `pyproject.toml`, `Cargo.toml`) and use detected dependencies as targets.
+
+Classify each target:
+
+- GitHub slug (`owner/repo`) or git URL → repo — DeepWiki (`context_deepwiki`), else clone.
+- Bare package name or `name@version` → library — Context7 (`context_context7`), else web + clone of docs repo when known.
+- Anything else → natural-language — Exa (`context_exa`) when `EXA_API_KEY` is set, else web search via `curl`.
+
+When `--method=` is passed, use the intersection of allowed and applicable methods. Empty intersection → skip and report.
+
+## Method 1: DeepWiki
+
+Best for: public GitHub repos needing an architecture overview quickly.
+
+1. `context_deepwiki` with `owner`/`repo` and `mode: "structure"` (e.g. `facebook` / `react`).
+2. `mode: "contents"` for the full wiki text, or `mode: "ask"` with `question` for targeted Q&A.
+3. Extract architecture summary and key relationships.
+
+Token isolation: structure → relevant pages → short architecture summary.
+Fallback on error: Method 4 (clone) + Method 5 (web) on GitHub docs/README.
+
+## Method 2: Context7
+
+Best for: up-to-date API docs and version-specific examples for packages/frameworks.
+
+1. `context_context7` with the library name as `query` (e.g. `fastapi`, `react`).
+2. Pass a `topic` (e.g. `auth`, `ssr`) for focused snippets; include the version in the query when given (`react@18`).
+3. Extract the minimum viable API surface + examples.
+
+Token isolation: resolve id → query → minimum viable API surface + examples.
+Fallback on error: official docs URLs via `curl`, or clone of the library repo docs.
+
+## Method 3: Exa
+
+Best for: real-world usage patterns and cross-web code examples.
+
+1. Call with a precise query (language/framework/version/identifiers).
+2. Prefer recent sources; dedupe near-identical snippets and mirrors.
+3. Return a short explanation with sources.
+
+Fallback when key missing / error: GitHub code search URLs / known docs via `curl`, or clone representative examples.
+
+## Method 4: Git clone
+
+Best for: private repos, deep implementation review, when other methods lack depth.
+
+1. `git clone <repo-url> /tmp/<repo-name> --depth=1`
+2. `read` key files: entry points, config, core modules.
+3. Map structure with `bash` find/ls; search with `bash` grep.
+4. Cleanup: `rm -rf /tmp/<repo-name>`.
+
+## Method 5: Web search + fetch
+
+Best for: rationale, changelogs, issues, migration guides.
+
+1. Derive version-anchored queries from the question or clone findings.
+2. Fetch high-signal URLs (official docs, GitHub issues/PRs, changelogs).
+3. Extract only relevant sections; cross-check against cloned code when available.
+4. Discard results older than ~2 years unless foundational.
+
+Query patterns:
+- Changelogs: `"<repo> CHANGELOG v<version>"`
+- Rationale: `"<repo> <concept> why OR rationale site:github.com"`
+- Known issues: `"<repo> <symbol> issue OR bug site:github.com"`
+- Migration: `"<repo> migrate from <old> to <new>"`
+
+## Method selection guide
+
+| Scenario | Primary | Fallback |
+|----------|---------|----------|
+| "How does X library work?" | Context7 | Web / clone |
+| "Architecture of Y repo" | DeepWiki | Git clone |
+| "Examples of Z pattern" | Exa | Context7 / web |
+| "Private/internal repo" | Git clone | — |
+| "What changed in v3?" | Context7 | Web |
+| "Why this design?" | Git clone → web | DeepWiki |
+| "Compare X vs Y" | Exa + Context7 | Web |
+| "Best practice for Z" | Web | Exa |
+
+## Combining methods
+
+1. DeepWiki / clone for architecture.
+2. Context7 for API surface.
+3. Exa / web for community patterns.
+4. Always prefer read-only operations; clean up `/tmp` clones.
+5. Return a synthesized summary only — drop raw bulk payloads.

package/skills/code-context/SKILL.md

@@ -1,127 +0,0 @@
----
-name: code-context
-description: This skill should be used when the user asks to "understand a codebase", "get code context", "research a library", "explore a repository", "find code examples", "look up documentation", asks a natural-language code/technology question (e.g. "how does X work", "X vs Y", "best practice for Z"), or wants to understand how a specific project, library, or concept works before making changes.
-disable-model-invocation: true
----
-
-# Code Context Retrieval
-
-This skill provides 5 methods for retrieving code context. Select methods based on the target: public GitHub repos, library docs, code search, direct inspection, or post-clone web enrichment.
-
-## Pi tools and runtime
-
-Use Pi built-ins: `bash`, `read`, `edit` (rarely), `write` (rarely), plus this package's native tools from `extensions/context-tools.ts`.
-
-| Method | Runtime |
-|--------|---------|
-| DeepWiki | `context_deepwiki` tool (always available; no key) |
-| Context7 | `context_context7` tool (always available; optional `CONTEXT7_API_KEY` for higher quota) |
-| Exa | `context_exa` tool (requires `EXA_API_KEY` env) |
-| Git clone | `bash` + `read` (always available) |
-| Web search+fetch | `bash` + `curl` (or host HTTP) |
-
-If a tool reports an error (e.g. `EXA_API_KEY` unset), skip it and use clone/web fallbacks. Report which methods ran.
-
-## Token Isolation (Critical)
-
-Prefer small intermediate summaries over dumping entire API payloads into the long-lived conversation:
-
-- **DeepWiki**: structure → relevant pages → short architecture summary
-- **Context7**: resolve id → query → minimum viable API surface + examples
-- **Exa**: query → dedupe near-identical snippets → short explanation
-- **Git clone**: clone to `/tmp/`, read entry points, cleanup, return structure + patterns
-- **Web**: targeted queries, fetch high-signal URLs only, validate against code when possible
-
-## Method 1: DeepWiki (AI-powered repo documentation)
-
-Best for: public GitHub repos needing architecture overview quickly.
-
-**Tool**: `context_deepwiki` (native, always available)
-
-**Process**:
-1. `context_deepwiki` with `owner`/`repo` and `mode: "structure"` (e.g. `facebook` / `react`)
-2. `context_deepwiki` `mode: "contents"` for the full wiki text, or `mode: "ask"` with a `question` for targeted Q&A
-3. Extract architecture summary and key relationships
-
-**Fallback on error**: Method 4 (clone) + Method 5 (web) on GitHub docs/README.
-
-## Method 2: Context7 (library documentation)
-
-Best for: up-to-date API docs and version-specific examples for packages/frameworks.
-
-**Tool**: `context_context7` (native, always available)
-
-**Process**:
-1. `context_context7` with the library name as `query` (e.g. `fastapi`, `react`)
-2. Pass a `topic` (e.g. `auth`, `ssr`) for focused snippets; include the version in the query when given (`react@18`)
-3. Extract the minimum viable API surface + examples
-
-**Fallback on error**: official docs URLs via `curl`, or clone of the library repo docs.
-
-## Method 3: Exa Code Search
-
-Best for: real-world usage patterns and cross-web code examples.
-
-**Tool**: `context_exa` (native; requires `EXA_API_KEY`)
-
-**Process**:
-1. Call with a precise query (language/framework/version/identifiers)
-2. Prefer recent sources; dedupe mirrors
-
-**Fallback when key missing / error**: GitHub code search URLs / known docs via `curl`, or clone representative examples.
-
-## Method 4: Git Clone (direct code inspection)
-
-Best for: private repos, deep implementation review, when other methods lack depth.
-
-**Process**:
-1. `git clone <repo-url> /tmp/<repo-name> --depth=1`
-2. `read` key files: entry points, config, core modules
-3. Map structure with `bash` find/ls; search with `bash` grep or Pi search tools if available
-4. Cleanup: `rm -rf /tmp/<repo-name>`
-
-## Method 5: Web Search + Fetch
-
-Best for: rationale, changelogs, issues, migration guides.
-
-**Tools**: `bash` + `curl` (or host HTTP client). There are no Pi built-ins named web search via `curl`/HTTP / HTTP fetch via `curl`.
-
-**Process**:
-1. Derive version-anchored queries from the question or clone findings
-2. Fetch high-signal URLs (official docs, GitHub issues/PRs, changelogs)
-3. Extract only relevant sections; cross-check against cloned code when available
-4. Discard results older than ~2 years unless foundational
-
-**Query patterns**:
-- Changelogs: `"<repo> CHANGELOG v<version>"`
-- Rationale: `"<repo> <concept> why OR rationale site:github.com"`
-- Known issues: `"<repo> <symbol> issue OR bug site:github.com"`
-- Migration: `"<repo> migrate from <old> to <new>"`
-
-## Target Classification
-
-- **Repo target** — `owner/repo` or git URL → DeepWiki (`context_deepwiki`) or Git Clone
-- **Library target** — package name / `name@version` → Context7 (`context_context7`) else web/docs clone
-- **Natural-language target** — question/comparison → Exa (`context_exa`) and/or Web; Context7 if a library is named
-
-When caller passes `--method=`, use the intersection of allowed and applicable methods. Empty intersection → skip and report.
-
-## Method Selection Guide
-
-| Scenario | Primary | Fallback |
-|----------|---------|----------|
-| "How does X library work?" | Context7 | Web / clone |
-| "Architecture of Y repo" | DeepWiki | Git Clone |
-| "Examples of Z pattern" | Exa | Context7 / web |
-| "Private/internal repo" | Git Clone | — |
-| "What changed in v3?" | Context7 | Web |
-| "Why this design?" | Git Clone → Web | DeepWiki |
-| "Compare X vs Y" | Exa + Context7 | Web |
-| "Best practice for Z" | Web | Exa |
-
-## Combining Methods
-
-1. DeepWiki / clone for architecture
-2. Context7 for API surface
-3. Exa / web for community patterns
-4. Always prefer read-only operations; clean up `/tmp` clones

package/skills/get-context/SKILL.md

@@ -1,38 +0,0 @@
----
-name: get-context
-description: Execute this when the user requests code context for a repository, library, or any natural-language code/technology question using DeepWiki, Context7, Exa, git clone, and/or web search+fetch.
----
-
-# get-context
-
-Run the full code-context workflow using Pi tools. Prefer keeping heavy lookups out of a single giant turn when possible — summarize intermediate results.
-
-## Pi tools and runtime
-
-| Capability | How |
-|------------|-----|
-| Clone / local files | `bash` (`git clone`), `read`, `bash` (find/grep) |
-| Web fetch | `bash` with `curl -fsSL` (or available HTTP client) |
-| DeepWiki / Context7 / Exa | Native tools from this package's `extensions/context-tools.ts`: `context_deepwiki`, `context_context7`, `context_exa` (Exa needs `EXA_API_KEY`) |
-
-If a native tool is unavailable (e.g. `EXA_API_KEY` unset), fall back to clone + web fetch methods from `/skill:code-context`.
-
-## Invocation args
-
-When invoked as `/skill:get-context <args>`, the text after the skill block is the user-provided arguments. Pi does not expand `$ARGUMENTS` placeholders inside skill bodies; use the trailing invocation text.
-
-1. Split into positional targets and optional `--method=` flag.
-   - `--method=` accepts a comma-separated list from `deepwiki,context7,exa,clone,web,all`. Default: `all`.
-   - Quoted strings are one target.
-   - Multiple positional tokens are multiple targets.
-2. Classify each target:
-   - GitHub slug (`owner/repo`) or git URL → repo (DeepWiki via `context_deepwiki`, else clone).
-   - Bare package name or `name@version` → library (Context7 via `context_context7`, else web + clone of docs repo when known).
-   - Anything else → natural-language (Exa via `context_exa` when `EXA_API_KEY` is set, else web search via `curl` to searchable sources / known docs URLs).
-3. Empty input: read dependency manifests in cwd (`package.json`, `go.mod`, `pyproject.toml`, `Cargo.toml`) and use detected dependencies as targets.
-
-## Execute
-
-1. Load and follow `/skill:code-context` (or `read` that skill file) for method selection and process detail.
-2. Run methods with Pi tools as above; do not invent Claude-only tools (`Task`, `WebSearch`, `WebFetch`).
-3. Return a synthesized summary only — drop raw bulk payloads.