prjct-cli 0.25.2 → 0.28.0

package/templates/commands/sync.md

@@ -205,6 +205,173 @@ EXTRACT: `{frontendType}` = "web" | "mobile" | "both" | null
 
 ---
 
+## Step 3.5: Deep Project Analysis (TRULY AGENTIC)
+
+**CRITICAL: Do NOT follow hardcoded rules. ANALYZE the actual project and UNDERSTAND what it is.**
+
+### 3.5.1 Detect Project Type (AGENTIC)
+
+**Look at the project root and DETERMINE what kind of project this is:**
+
+```bash
+ls -la
+```
+
+ANALYZE what files exist and REASON about the project type:
+
+| If you see... | Project is... | Ecosystem |
+|---------------|---------------|-----------|
+| `Gemfile` | Ruby/Rails | Ruby |
+| `requirements.txt`, `pyproject.toml`, `setup.py` | Python | Python |
+| `go.mod` | Go | Go |
+| `Cargo.toml` | Rust | Rust |
+| `composer.json` | PHP | PHP |
+| `pom.xml`, `build.gradle` | Java | JVM |
+| `*.csproj`, `*.sln` | .NET/C# | .NET |
+| `mix.exs` | Elixir | Elixir |
+| `Package.swift` | Swift | Apple |
+| `package.json` | Node.js/JavaScript | JavaScript |
+| `pubspec.yaml` | Flutter/Dart | Dart |
+| `Makefile` only | C/C++ or custom | Native |
+
+SET: `{ecosystem}` = detected ecosystem
+SET: `{projectType}` = specific type (e.g., "Rails", "Django", "Next.js", "Go API")
+
+### 3.5.2 Detect Commands FOR THIS PROJECT (AGENTIC)
+
+**Based on the ecosystem, LOOK for the actual commands this project uses:**
+
+#### Ruby/Rails
+```bash
+cat Gemfile | head -20  # See dependencies
+test -f bin/rails && echo "rails"
+test -f Rakefile && echo "rake"
+```
+→ Commands: `bundle install`, `rails s`, `rails c`, `rake db:migrate`, `rspec`
+
+#### Python
+```bash
+test -f pyproject.toml && cat pyproject.toml | head -20
+test -f requirements.txt && echo "pip"
+which poetry && echo "poetry"
+which uv && echo "uv"
+```
+→ Commands: `pip install -r requirements.txt` OR `poetry install` OR `uv sync`
+
+#### Go
+```bash
+cat go.mod | head -5
+```
+→ Commands: `go build`, `go test ./...`, `go run .`
+
+#### Rust
+```bash
+cat Cargo.toml | head -10
+```
+→ Commands: `cargo build`, `cargo test`, `cargo run`
+
+#### Node.js/JavaScript
+```bash
+# Check lockfile to determine package manager
+test -f bun.lockb && echo "bun"
+test -f pnpm-lock.yaml && echo "pnpm"
+test -f yarn.lock && echo "yarn"
+test -f package-lock.json && echo "npm"
+cat package.json | grep -A 20 '"scripts"'
+```
+→ Commands: Use detected package manager + scripts from package.json
+
+**EXTRACT the actual commands:**
+- `{installCommand}` = what installs dependencies
+- `{runCommand}` = how to run scripts
+- `{testCommand}` = how to run tests
+- `{buildCommand}` = how to build
+- `{devCommand}` = how to run dev server
+
+### 3.5.3 Detect Code Conventions (AGENTIC)
+
+**LOOK at actual files to understand patterns:**
+
+```bash
+# List some source files
+find . -type f \( -name "*.rb" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.ts" -o -name "*.js" \) -not -path "*/node_modules/*" -not -path "*/.git/*" | head -10
+
+# Check for linters/formatters
+ls .rubocop.yml .eslintrc* .prettierrc* pyproject.toml rustfmt.toml .golangci.yml 2>/dev/null
+```
+
+ANALYZE and DETERMINE:
+- `{namingConvention}` = based on actual file names
+- `{linter}` = what linter is configured
+- `{formatter}` = what formatter is used
+
+### 3.5.4 Detect Project Structure (AGENTIC)
+
+```bash
+ls -d */ 2>/dev/null | head -10
+```
+
+UNDERSTAND the structure:
+- Where is source code?
+- Where are tests?
+- Is it a monorepo?
+- What's the architecture?
+
+### 3.5.5 Generate Project-Specific Rules (AGENTIC)
+
+**Based on YOUR ANALYSIS, generate rules that make sense for THIS project.**
+
+Think: "What does a developer working on this project need to know?"
+
+Examples:
+- Rails project: "Use `bundle exec` for Ruby commands", "Migrations: `rails db:migrate`"
+- Python/Poetry: "Use `poetry run` to run commands in venv"
+- Go project: "Use `go test ./...` to run all tests"
+- Rust project: "Use `cargo fmt` before commits"
+- Node/bun: "Use `bun` not npm - this project has bun.lockb"
+
+### 3.5.6 Write analysis/repo-analysis.json
+
+```bash
+mkdir -p {globalPath}/analysis
+```
+
+WRITE: `{globalPath}/analysis/repo-analysis.json`
+
+```json
+{
+  "analyzedAt": "{timestamp}",
+  "ecosystem": "{ecosystem}",
+  "projectType": "{projectType}",
+  "commands": {
+    "install": "{installCommand}",
+    "run": "{runCommand}",
+    "test": "{testCommand}",
+    "build": "{buildCommand}",
+    "dev": "{devCommand}",
+    "lint": "{lintCommand}",
+    "format": "{formatCommand}"
+  },
+  "conventions": {
+    "naming": "{namingConvention}",
+    "linter": "{linter}",
+    "formatter": "{formatter}"
+  },
+  "structure": {
+    "srcDir": "{srcDir}",
+    "testDir": "{testDir}",
+    "isMonorepo": {isMonorepo}
+  },
+  "rules": [
+    "{rule1 - generated based on analysis}",
+    "{rule2 - generated based on analysis}",
+    "..."
+  ]
+}
+```
+
+---
+
 ## Step 4: Regenerate ALL Context Files
 
 ### 4.1 Read Storage (Source of Truth)
@@ -310,74 +477,122 @@ WRITE: `{globalPath}/context/shipped.md`
 
 ---
 
-## Step 5: Update context/CLAUDE.md
+## Step 5: Update context/CLAUDE.md (CRITICAL - AGENTIC)
+
+**ALWAYS OVERWRITE** this file on every sync.
+
+READ: `{globalPath}/analysis/repo-analysis.json` to get the analysis you just did.
 
 WRITE: `{globalPath}/context/CLAUDE.md`
 
+**Generate this file BASED ON YOUR ANALYSIS. The content below is a TEMPLATE - adapt it to what you found.**
+
 ```markdown
-# {projectName} - Project Context
+# {projectName} - Project Rules
 <!-- projectId: {projectId} -->
 <!-- Generated: {GetTimestamp()} -->
+<!-- Ecosystem: {ecosystem} | Type: {projectType} -->
 
-## Quick Reference
+## THIS PROJECT ({ecosystem})
 
-| Field | Value |
-|-------|-------|
-| **Name** | {projectName} |
-| **Version** | {version} |
-| **Stack** | {stack} |
-| **Files** | {fileCount} |
-| **Commits** | {commitCount} |
-| **Branch** | {currentBranch} |
-| **Path** | {cwd} |
-| **Last Sync** | {GetTimestamp()} |
+**Type:** {projectType}
+**Path:** {cwd}
 
-## Current Git Status
+### Commands (USE THESE, NOT OTHERS)
 
-**Branch**: `{currentBranch}`
-**Uncommitted Changes**: {hasUncommittedChanges ? "Yes" : "Clean"}
+| Action | Command |
+|--------|---------|
+| Install dependencies | \`{installCommand}\` |
+| Run dev server | \`{devCommand}\` |
+| Run tests | \`{testCommand}\` |
+| Build | \`{buildCommand}\` |
+| Lint | \`{lintCommand}\` |
+| Format | \`{formatCommand}\` |
 
-{IF hasUncommittedChanges}
-### Modified Files
-{list of modified files}
+### Project-Specific Rules
+
+{FOR EACH rule in analysis.rules}
+- {rule}
+{END FOR}
+
+### Code Conventions
+
+- **Naming**: {namingConvention}
+- **Linter**: {linter}
+- **Formatter**: {formatter}
+{IF isMonorepo}
+- **Monorepo**: Check which package you're in before running commands
 {ENDIF}
 
-## PROJECT DATA
+---
 
-### Dependencies
-{list dependencies from package.json}
+## DO vs DON'T (FOR THIS PROJECT)
 
-### Scripts
-{list scripts from package.json}
+| DO | DON'T |
+|----|-------|
+| \`{installCommand}\` | Wrong install command for this ecosystem |
+| \`{testCommand}\` | Wrong test command |
+| Read files before editing | Assume contents |
+| Use Task(Explore) to understand | Jump to conclusions |
+| Ask when uncertain | Make assumptions |
 
-## CURRENT STATE
+---
 
-**Now:** {currentTask or "_No active task_"}
+## PRJCT RULES
 
-**Queue ({queue.tasks.length}):**
-{list first 5 tasks}
+### Path Resolution
+**ALL prjct writes go to**: \`~/.prjct-cli/projects/{projectId}/\`
+- NEVER write to \`.prjct/\`
+- NEVER write to \`./\` for prjct data
 
-**Ideas ({ideas.ideas.length}):**
-{list first 3 ideas}
+### Workflow
+\`\`\`
+p. sync → p. task "desc" → [work] → p. done → p. ship
+\`\`\`
 
-## DATA LOCATION
+| Command | Action |
+|---------|--------|
+| \`p. sync\` | Re-analyze project |
+| \`p. task X\` | Start task |
+| \`p. done\` | Complete subtask |
+| \`p. ship X\` | Ship feature |
+
+---
+
+## PROJECT STATE
+
+| Field | Value |
+|-------|-------|
+| Name | {projectName} |
+| Version | {version} |
+| Ecosystem | {ecosystem} |
+| Branch | {currentBranch} |
+| Files | {fileCount} |
+
+**Current Task:** {currentTask.description || "_None_"}
+**Queue:** {queue.tasks.length} tasks
+
+---
+
+## AGENTS
+
+Load from \`{globalPath}/agents/\`:
+{FOR EACH agent in generatedAgents}
+- \`{agent}.md\`
+{END FOR}
+
+---
+
+## STRUCTURE
 
 \`\`\`
-~/.prjct-cli/projects/{projectId}/
-├── storage/        # JSON (source of truth)
-│   ├── state.json
-│   ├── queue.json
-│   ├── ideas.json
-│   └── shipped.json
-├── context/        # MD (for Claude)
-│   ├── CLAUDE.md
-│   ├── now.md
-│   ├── next.md
-│   ├── ideas.md
-│   └── shipped.md
-├── sync/           # Backend sync
-│   └── pending.json
-└── agents/         # Specialists
+{srcDir}/           # Source code
+{testDir}/          # Tests
+{globalPath}/
+├── storage/        # prjct state
+├── context/        # This file
+├── agents/         # Domain experts
+└── analysis/       # repo-analysis.json
 \`\`\`
 ```
 
@@ -521,6 +736,174 @@ Track which agents were generated for output:
 
 ---
 
+## Step 7.5: Install Claude Code Skills (AGENTIC)
+
+**CRITICAL: This step is AGENTIC. Search claude-plugins.dev dynamically to find the best skills.**
+
+Skills in Claude Code are markdown files in `~/.claude/skills/`. We search the marketplace and download the best matching skills for each agent.
+
+### 7.5.1 Check Existing Skills
+
+```bash
+ls ~/.claude/skills/*.md 2>/dev/null || echo "none"
+```
+
+SET: `{existingSkills}` = list of installed skill files
+
+### 7.5.2 Search & Install Skills (AGENTIC)
+
+**For each generated agent, search claude-plugins.dev and install the best skill.**
+
+```
+{skillsToFind} = [
+  { agent: "frontend", searchTerms: ["frontend-design", "react", "ui components"] },
+  { agent: "uxui", searchTerms: ["ux-designer", "frontend-design", "ui ux"] },
+  { agent: "backend", searchTerms: ["{ecosystem} backend", "api design", "backend patterns"] },
+  { agent: "testing", searchTerms: ["testing", "test automation", "{ecosystem} testing"] },
+  { agent: "devops", searchTerms: ["devops", "ci cd", "docker kubernetes"] },
+  { agent: "prjct-planner", searchTerms: ["feature development", "architecture", "planning"] },
+  { agent: "prjct-shipper", searchTerms: ["code review", "pr review", "shipping"] }
+]
+
+FOR EACH entry in {skillsToFind}:
+  IF {entry.agent} IN {generatedAgents}:
+
+    # Step A: Search claude-plugins.dev
+    USE WebFetch:
+      url: "https://claude-plugins.dev/skills?q={entry.searchTerms[0]}"
+      prompt: "Find the best skill for {entry.agent}. Return: skill name, author, install URL"
+
+    SET: {searchResult} = result
+
+    # Step B: Analyze results and pick best match
+    ANALYZE {searchResult}:
+      - Prefer @anthropics skills (official)
+      - Prefer skills with high download count
+      - Match the agent's domain
+
+    SET: {bestSkill} = selected skill
+
+    # Step C: Check if already installed
+    IF {bestSkill.name}.md NOT IN {existingSkills}:
+
+      # Step D: Get skill content from GitHub
+      USE WebFetch:
+        url: "{bestSkill.githubUrl}/raw/main/skills/{bestSkill.name}.md"
+        prompt: "Get the complete skill markdown content"
+
+      SET: {skillContent} = result
+
+      # Step E: Install to ~/.claude/skills/
+      ```bash
+      mkdir -p ~/.claude/skills
+      ```
+
+      WRITE: `~/.claude/skills/{bestSkill.name}.md`
+      CONTENT: {skillContent}
+
+      OUTPUT: "📦 Installed skill: {bestSkill.name} (from {bestSkill.author})"
+      ADD {bestSkill} to {installedSkills}
+
+    ELSE:
+      OUTPUT: "✓ Skill exists: {bestSkill.name}"
+      ADD {bestSkill.name} to {verifiedSkills}
+```
+
+### 7.5.3 Skill Search Fallbacks
+
+If WebFetch fails or no results found:
+
+```
+FALLBACK SKILLS (use these if search fails):
+- frontend/uxui → "frontend-design" from @anthropics/claude-code
+- backend (JS/TS) → Search "typescript backend patterns"
+- backend (Python) → Search "python backend patterns"
+- testing → Search "testing automation"
+- devops → Search "devops ci cd"
+- planner → Search "architecture planning"
+- shipper → Search "code review"
+```
+
+### 7.5.4 Create Custom Skill if Not Found
+
+If no suitable skill found on marketplace, CREATE a minimal skill:
+
+```markdown
+---
+name: {agent}-skill
+description: Custom skill for {agent} agent
+---
+
+# {Agent} Skill
+
+This is a custom skill for the {agent} domain.
+
+## Expertise
+{Based on agent's domain - frontend, backend, etc.}
+
+## Patterns
+{Common patterns for this domain}
+```
+
+WRITE to: `~/.claude/skills/{agent}-custom.md`
+
+### 7.5.5 Save Skills Configuration
+
+```bash
+mkdir -p {globalPath}/config
+```
+
+WRITE: `{globalPath}/config/skills.json`
+
+```json
+{
+  "projectId": "{projectId}",
+  "ecosystem": "{ecosystem}",
+  "installedAt": "{GetTimestamp()}",
+  "searchedAt": "{GetTimestamp()}",
+  "skills": [
+    {
+      "name": "{skill.name}",
+      "source": "{skill.source}",
+      "author": "{skill.author}",
+      "path": "~/.claude/skills/{skill.name}.md",
+      "linkedAgents": ["{agents that use this skill}"]
+    }
+  ],
+  "agentSkillMap": {
+    "{agent}": "{skill.name}"
+  }
+}
+```
+
+### 7.5.6 Update Agent Frontmatter
+
+FOR EACH agent file in `{globalPath}/agents/`:
+  READ agent file
+  GET skill from agentSkillMap[agent.name]
+
+  IF skill exists AND frontmatter.skills is missing:
+    UPDATE frontmatter to include: `skills: [{skill}]`
+    WRITE updated agent file
+
+### 7.5.7 Output Summary
+
+```
+SET: {skillsInstalled} = list of newly installed
+SET: {skillsVerified} = list of already existing
+SET: {skillsCreated} = list of custom-created
+SET: {totalSkills} = count of all
+
+OUTPUT:
+📦 Skills Synchronized
+├── Installed: {skillsInstalled.length} new from marketplace
+├── Verified: {skillsVerified.length} already exist
+├── Created: {skillsCreated.length} custom skills
+└── Location: ~/.claude/skills/
+```
+
+---
+
 ## Step 8: Log to Memory
 
 APPEND to: `{globalPath}/memory/events.jsonl`
@@ -607,6 +990,16 @@ IF cloudSync AND no syncError:
 └── 🎨 UX/UI: uxui.md (Priority: UX > UI)
 {ENDIF}
 
+📦 Skills ({totalSkills})
+├── Installed: {skillsInstalled.length ? skillsInstalled.join(', ') : 'none'}
+├── Verified: {skillsVerified.length ? skillsVerified.join(', ') : 'none'}
+└── Config: {globalPath}/config/skills.json
+
+🔗 Agent → Skill Mapping
+{FOR EACH entry in agentSkillMap WHERE entry.skill != null}
+├── {entry.agent}.md → /{entry.skill}
+{END FOR}
+
 {IF isVersionUpgrade}
 ✨ New Features Available in v{cliVersion}:
 
@@ -668,9 +1061,11 @@ Next: /p:task "your next task"
 │   ├── next.md              # Queue
 │   ├── ideas.md             # Ideas
 │   └── shipped.md           # Shipped
+├── config/                   # Configuration (NEW)
+│   └── skills.json          # Agent-to-skill mappings
 ├── sync/                     # Backend Sync
 │   └── pending.json         # Events queue
-├── agents/                   # Specialists (legacy)
+├── agents/                   # Specialists
 ├── memory/                   # Audit Trail
 │   └── events.jsonl
 └── project.json             # Metadata