@blxzer/pactile 0.5.0 → 0.6.0-beta.2

package/dist/templates/common/bundled-skills/pactile-spec-bootstrap/references/mcp-setup.md

@@ -1,90 +1,18 @@
-# MCP Setup
-
-GitNexus and ABCoder are recommended when bootstrapping Pactile specs because they expose architecture and AST context to the agent. They are tool choices, not platform requirements. Configure them through whatever MCP mechanism your agent host provides.
-
-## GitNexus
-
-GitNexus builds a code knowledge graph from the repository. Use it for module boundaries, execution flows, dependency relationships, blast radius, and graph queries.
-
-### Install and Index
-
-```bash
-# Run from the repository root.
-npx gitnexus analyze
-
-# Check index status.
-npx gitnexus status
-
-# Re-index after code changes when the analysis is stale.
-npx gitnexus analyze
-```
-
-The index is written to `.gitnexus/`. Keep embeddings only if the project already uses them; otherwise a normal index is enough for spec bootstrapping.
-
-### MCP Server Command
-
-Use this server command in the host's MCP configuration:
-
-```bash
-npx -y gitnexus mcp
-```
-
-### Useful Tools
-
-| Tool | Purpose |
-|------|---------|
-| `gitnexus_query` | Find execution flows and functional areas by concept |
-| `gitnexus_context` | Inspect callers, callees, references, and process participation for a symbol |
-| `gitnexus_impact` | Understand blast radius before changing a symbol |
-| `gitnexus_detect_changes` | Check changed symbols and affected flows before finishing |
-| `gitnexus_cypher` | Run direct graph queries |
-| `gitnexus_list_repos` | List indexed repositories |
-
-## ABCoder
-
-ABCoder parses code into UniAST and gives precise package, file, and node-level structure. Use it for signatures, type shapes, implementations, dependencies, and reverse references.
-
-### Install
-
-```bash
-go install github.com/cloudwego/abcoder@latest
-abcoder --help
-```
-
-### Parse Repositories
-
-```bash
-abcoder parse /absolute/path/to/package \
-  --lang typescript \
-  --name package-name \
-  --output ~/abcoder-asts
-```
-
-For monorepos, parse each package with a stable `--name` so task notes can reference the same repository names.
-
-### MCP Server Command
-
-Use this server command in the host's MCP configuration:
-
-```bash
-abcoder mcp ~/abcoder-asts
-```
-
-### Useful Tools
-
-| Tool | Layer | Purpose |
-|------|-------|---------|
-| `list_repos` | 1 | List parsed repositories |
-| `get_repo_structure` | 2 | Inspect packages and files |
-| `get_package_structure` | 3 | Inspect nodes within a package |
-| `get_file_structure` | 3 | Inspect functions, classes, types, and signatures in a file |
-| `get_ast_node` | 4 | Retrieve code, dependencies, references, and implementations |
-
-## Verification
-
-After configuration, verify from the agent host that both MCP servers are visible. Then run one simple query against each server before starting the spec writing pass.
-
-```bash
-ls .gitnexus/meta.json
-ls ~/abcoder-asts/*.json
-```
+# Code Graph and MCP Setup
+
+Pactile does not recommend a specific code-graph or AST tool. Which one is worth running depends on your language mix, the license you can accept, the index size you are willing to carry, and whether the tool writes into files Pactile also manages. Those trade-offs belong to the project, not to this skill.
+
+Use whatever code graph, AST, or language tooling you already have, and register it through your agent host's own MCP mechanism. If you have nothing installed, direct source reads plus exact search are enough to bootstrap specs — the workflow does not require a graph.
+
+## What to check before adopting a tool
+
+- **License.** Several popular code-graph tools are source-available rather than open source. Check the actual terms before making one a recommendation for a commercial codebase.
+- **Index cost.** Graph indexes can be large and can add resident context across a long session. Prefer a tool you can afford to keep indexed over one you will disable after the first pass.
+- **Side effects on shared files.** Some tools write `AGENTS.md` / `CLAUDE.md` or register host hooks on their own. That can collide with the Pactile managed block. Reconcile deliberately instead of letting two writers fight over one file.
+- **Overlap.** If you already run something that resolves symbols and call chains, a second graph tool usually adds cost without adding evidence.
+
+## Using it during spec bootstrap
+
+Register the server in your host's MCP configuration, verify from the agent host that it is actually visible, then run one simple query before starting the spec-writing pass. A tool that is configured but not loaded is worse than no tool: it invites claims that were never checked.
+
+Whatever you use, confirm a result against the current source before writing it into a spec. Graph and AST output is orientation, not proof.

package/dist/templates/common/bundled-skills/pactile-spec-bootstrap/references/repository-analysis.md

@@ -1,59 +1,41 @@
-# Repository Analysis
-
-The goal is to discover the project's real architecture before writing rules. Do not start from generic spec templates and fill blanks. Start from the code, then let the spec structure follow.
-
-## Analysis Order
-
-1. Read the existing `.pactile/spec/` tree and note which files are templates, outdated, or already project-specific.
-2. Inspect package manifests, build scripts, workspace config, and top-level documentation to identify packages and runtime layers.
-3. Use GitNexus for execution flows, module clusters, dependency hubs, and impact-sensitive areas.
-4. Use ABCoder or language-native tooling for exact signatures, types, class boundaries, and implementation examples.
-5. Read representative source and test files directly before turning any finding into a spec rule.
-
-## What To Capture
-
-| Area | Questions |
-|------|-----------|
-| Package boundaries | What does each package own? What imports cross boundaries? |
-| Runtime layers | Which code is CLI, backend, frontend, worker, shared library, test-only, or tooling? |
-| Core abstractions | Which types, services, stores, commands, routes, or adapters define the system shape? |
-| Data flow | Where does user input enter, how is it validated, and where does state persist? |
-| Error handling | How are failures represented, logged, surfaced, and tested? |
-| Configuration | Where do defaults, environment config, generated files, and templates live? |
-| Tests | Which test styles are trusted examples for new work? |
-
-## GitNexus Usage
-
-Start broad, then inspect specific symbols:
-
-```text
-gitnexus_query({query: "CLI command execution flow"})
-gitnexus_query({query: "template generation and migration"})
-gitnexus_context({name: "SymbolName"})
-gitnexus_cypher({query: "MATCH (n)-[r]->(m) RETURN n.name, type(r), m.name LIMIT 30"})
-```
-
-Use GitNexus results to find important files and flows. Do not quote graph output as the final authority until you have checked the relevant source files.
-
-## ABCoder Usage
-
-Use ABCoder when the spec needs exact code shapes:
-
-```text
-list_repos()
-get_repo_structure({repo_name: "package-name"})
-get_file_structure({repo_name: "package-name", file_path: "src/example.ts"})
-get_ast_node({repo_name: "package-name", node_ids: [{mod_path: "...", pkg_path: "...", name: "SymbolName"}]})
-```
-
-ABCoder is most valuable for documenting constructor patterns, function signatures, type contracts, and reference chains.
-
-## Analysis Notes
-
-Keep short notes while analyzing. The notes should include:
-
-- Package or layer name.
-- Files that define the local pattern.
-- Rules the spec should teach.
-- Anti-patterns found in old code, comments, tests, or migration paths.
-- Spec files that should be created, deleted, renamed, or merged.
+# Repository Analysis
+
+The goal is to discover the project's real architecture before writing rules. Do not start from generic spec templates and fill blanks. Start from the code, then let the spec structure follow.
+
+## Analysis Order
+
+1. Read the existing `.pactile/spec/` tree and note which files are templates, outdated, or already project-specific.
+2. Inspect package manifests, build scripts, workspace config, and top-level documentation to identify packages and runtime layers.
+3. If you already run a code graph, use it for execution flows, module clusters, dependency hubs, and impact-sensitive areas.
+4. Use AST or language-native tooling for exact signatures, types, class boundaries, and implementation examples.
+5. Read representative source and test files directly before turning any finding into a spec rule.
+
+## What To Capture
+
+| Area | Questions |
+|------|-----------|
+| Package boundaries | What does each package own? What imports cross boundaries? |
+| Runtime layers | Which code is CLI, backend, frontend, worker, shared library, test-only, or tooling? |
+| Core abstractions | Which types, services, stores, commands, routes, or adapters define the system shape? |
+| Data flow | Where does user input enter, how is it validated, and where does state persist? |
+| Error handling | How are failures represented, logged, surfaced, and tested? |
+| Configuration | Where do defaults, environment config, generated files, and templates live? |
+| Tests | Which test styles are trusted examples for new work? |
+
+## Graph and AST Tooling
+
+Pactile does not recommend a specific brand here — see [mcp-setup.md](./mcp-setup.md) for the trade-offs to weigh before adopting one. The method matters more than the tool:
+
+- **Start broad, then narrow.** Use the graph to find candidate flows and hubs, then resolve specific symbols. Do not treat a graph result as the final authority: check the relevant source files before it becomes a spec rule.
+- **Use AST tooling for exact shapes.** Signatures, type contracts, class boundaries, and reference chains are where structural output is most valuable — and also where stale indexes mislead most easily.
+- **Fall back without ceremony.** With no graph installed, exact search plus direct reads are sufficient. The analysis order above does not depend on a graph being present.
+
+## Analysis Notes
+
+Keep short notes while analyzing. The notes should include:
+
+- Package or layer name.
+- Files that define the local pattern.
+- Rules the spec should teach.
+- Anti-patterns found in old code, comments, tests, or migration paths.
+- Spec files that should be created, deleted, renamed, or merged.

package/dist/templates/common/bundled-skills/pactile-spec-bootstrap/references/spec-task-planning.md

@@ -1,61 +1,61 @@
-# Spec Task Planning
-
-Use a single agent as the default execution model. The agent may create Pactile tasks for traceability, but the skill should not require a specific platform, CLI, or parallel worker model.
-
-## Decomposition
-
-Create spec work units around real ownership boundaries:
-
-- One package when a package has its own conventions.
-- One layer when the same package has distinct frontend, backend, CLI, worker, or shared-library rules.
-- One cross-cutting guide when a pattern spans packages and is not owned by one layer.
-
-Avoid artificial decomposition. A small library usually needs one focused spec pass, not several tasks.
-
-## Task Shape
-
-When a Pactile task is useful, write a concise PRD with these sections:
-
-```markdown
-# Fill <package-or-layer> Pactile Specs
-
-## Goal
-Write project-specific `.pactile/spec/` guidance for <scope>.
-
-## Scope
-- Spec directory:
-- Source directories to inspect:
-- Tests to inspect:
-- Out of scope:
-
-## Architecture Context
-Summarize the concrete findings from repository analysis.
-
-## Files To Create Or Update
-- `.pactile/spec/.../index.md`
-- `.pactile/spec/.../<topic>.md`
-
-## Rules
-- Adapt the spec file set to the real codebase.
-- Use real source examples with file paths.
-- Remove template-only sections that do not apply.
-- Do not modify product source code unless the task explicitly asks for it.
-
-## Acceptance Criteria
-- [ ] Specs contain concrete examples and anti-patterns from the repository.
-- [ ] No placeholder text remains.
-- [ ] Index files match the final spec files.
-- [ ] Claims are backed by source files, tests, or project docs.
-```
-
-## Optional Helper Agents
-
-If the host supports subagents, helpers can inspect independent packages or run verification. They are optional. The main agent still owns integration and final quality.
-
-Helper tasks must have clear ownership:
-
-- Read-only research tasks may inspect any source needed for the assigned scope.
-- Write tasks should own disjoint spec directories.
-- Verification tasks should check placeholder removal, broken links, and consistency.
-
-Do not encode helper-agent names, vendor-specific commands, or platform-specific routing in the skill. Put only the required work and acceptance criteria in the task.
+# Spec Task Planning
+
+Use a single agent as the default execution model. The agent may create Pactile tasks for traceability, but the skill should not require a specific platform, CLI, or parallel worker model.
+
+## Decomposition
+
+Create spec work units around real ownership boundaries:
+
+- One package when a package has its own conventions.
+- One layer when the same package has distinct frontend, backend, CLI, worker, or shared-library rules.
+- One cross-cutting guide when a pattern spans packages and is not owned by one layer.
+
+Avoid artificial decomposition. A small library usually needs one focused spec pass, not several tasks.
+
+## Task Shape
+
+When a Pactile task is useful, write a concise PRD with these sections:
+
+```markdown
+# Fill <package-or-layer> Pactile Specs
+
+## Goal
+Write project-specific `.pactile/spec/` guidance for <scope>.
+
+## Scope
+- Spec directory:
+- Source directories to inspect:
+- Tests to inspect:
+- Out of scope:
+
+## Architecture Context
+Summarize the concrete findings from repository analysis.
+
+## Files To Create Or Update
+- `.pactile/spec/.../index.md`
+- `.pactile/spec/.../<topic>.md`
+
+## Rules
+- Adapt the spec file set to the real codebase.
+- Use real source examples with file paths.
+- Remove template-only sections that do not apply.
+- Do not modify product source code unless the task explicitly asks for it.
+
+## Acceptance Criteria
+- [ ] Specs contain concrete examples and anti-patterns from the repository.
+- [ ] No placeholder text remains.
+- [ ] Index files match the final spec files.
+- [ ] Claims are backed by source files, tests, or project docs.
+```
+
+## Optional Helper Agents
+
+If the host supports subagents, helpers can inspect independent packages or run verification. They are optional. The main agent still owns integration and final quality.
+
+Helper tasks must have clear ownership:
+
+- Read-only research tasks may inspect any source needed for the assigned scope.
+- Write tasks should own disjoint spec directories.
+- Verification tasks should check placeholder removal, broken links, and consistency.
+
+Do not encode helper-agent names, vendor-specific commands, or platform-specific routing in the skill. Put only the required work and acceptance criteria in the task.

package/dist/templates/common/bundled-skills/pactile-spec-bootstrap/references/spec-writing.md

@@ -1,70 +1,70 @@
-# Spec Writing
-
-Pactile specs are coding guidance for future agents. They should explain how to work in this repository, not how a generic project might be organized.
-
-## Write From Evidence
-
-Each important rule should be backed by one of these:
-
-- A source file that demonstrates the preferred pattern.
-- A test file that shows expected behavior.
-- A project document that defines the convention.
-- A repeated pattern across multiple files.
-
-Use short snippets only when they make the rule clearer. Prefer linking to the file path and naming the symbol or behavior.
-
-## File Structure
-
-Keep the spec tree aligned with the project:
-
-- Keep `index.md` as the navigation file for the spec directory.
-- Split topics when developers would look for them independently.
-- Merge topics when separate files would repeat the same rule.
-- Delete template files that do not apply.
-- Add new files for important local patterns the template missed.
-
-## Content Standards
-
-Good spec sections include:
-
-- When the rule applies.
-- The local pattern to follow.
-- The source or test files that prove the pattern.
-- Common mistakes or anti-patterns.
-- Verification commands or checks when they are specific and reliable.
-
-Avoid:
-
-- Placeholder prose.
-- Generic framework advice.
-- Tool instructions that only work in one agent host.
-- Long copied code blocks.
-- Rules based on a single accidental implementation detail.
-
-## Example Shape
-
-```markdown
-## Command Handlers
-
-Command handlers should keep argument parsing, validation, and side effects separate. The local pattern is:
-
-- Parse CLI flags at the command boundary.
-- Convert raw inputs into typed task options before invoking core logic.
-- Keep filesystem writes in the command or service layer, not in template helpers.
-
-Reference files:
-- `packages/cli/src/commands/example.ts`
-- `packages/cli/test/commands/example.test.ts`
-
-Avoid passing raw `process.argv` or unvalidated config objects into shared helpers.
-```
-
-## Final Pass
-
-Before finishing:
-
-```bash
-grep -R "To be filled\\|TODO: fill\\|placeholder" .pactile/spec
-```
-
-Also check links, index files, and whether any spec still describes a template rather than this repository.
+# Spec Writing
+
+Pactile specs are coding guidance for future agents. They should explain how to work in this repository, not how a generic project might be organized.
+
+## Write From Evidence
+
+Each important rule should be backed by one of these:
+
+- A source file that demonstrates the preferred pattern.
+- A test file that shows expected behavior.
+- A project document that defines the convention.
+- A repeated pattern across multiple files.
+
+Use short snippets only when they make the rule clearer. Prefer linking to the file path and naming the symbol or behavior.
+
+## File Structure
+
+Keep the spec tree aligned with the project:
+
+- Keep `index.md` as the navigation file for the spec directory.
+- Split topics when developers would look for them independently.
+- Merge topics when separate files would repeat the same rule.
+- Delete template files that do not apply.
+- Add new files for important local patterns the template missed.
+
+## Content Standards
+
+Good spec sections include:
+
+- When the rule applies.
+- The local pattern to follow.
+- The source or test files that prove the pattern.
+- Common mistakes or anti-patterns.
+- Verification commands or checks when they are specific and reliable.
+
+Avoid:
+
+- Placeholder prose.
+- Generic framework advice.
+- Tool instructions that only work in one agent host.
+- Long copied code blocks.
+- Rules based on a single accidental implementation detail.
+
+## Example Shape
+
+```markdown
+## Command Handlers
+
+Command handlers should keep argument parsing, validation, and side effects separate. The local pattern is:
+
+- Parse CLI flags at the command boundary.
+- Convert raw inputs into typed task options before invoking core logic.
+- Keep filesystem writes in the command or service layer, not in template helpers.
+
+Reference files:
+- `packages/cli/src/commands/example.ts`
+- `packages/cli/test/commands/example.test.ts`
+
+Avoid passing raw `process.argv` or unvalidated config objects into shared helpers.
+```
+
+## Final Pass
+
+Before finishing:
+
+```bash
+grep -R "To be filled\\|TODO: fill\\|placeholder" .pactile/spec
+```
+
+Also check links, index files, and whether any spec still describes a template rather than this repository.