palskills 1.0.4 → 1.0.5

package/README.md

@@ -48,17 +48,19 @@ palskills
 ║     AI Development Pipeline          ║
 ╚══════════════════════════════════════╝
 
-  Select coding agent:
+  What do you want to do?
 
-  [1] Codex CLI     → .codex.md
-  [2] Cursor        → .cursorrules
-  [3] Claude Code   → CLAUDE.md
-  [4] All           → generate all
+  [1] Learn Project   → bootstrap .palbox/ (Lyleen)
+  [2] Codex CLI       → .codex.md
+  [3] Cursor          → .cursorrules
+  [4] Claude Code     → CLAUDE.md
+  [5] All Agents      → generate all configs
 
-  Choose [1-4]:
+  Choose [1-5]:
 ```
 
-Select an agent to instantly generate its config file with SOLID + SRP rules + palbox knowledge graph conventions.
+**Step 1:** Pick `[1]` to analyze the project and create a `.palbox/` knowledge graph.  
+**Step 2:** Pick `[2-5]` to generate agent configs with SOLID + SRP + palbox conventions.
 
 ### One-shot (without installing)
 ```bash

package/bin/palskills.js

@@ -29,22 +29,30 @@ async function main() {
   box('PALSKILLS\nAI Development Pipeline');
 
   console.log('');
-  console.log(`  ${BOLD}Select coding agent:${NC}`);
+  console.log(`  ${BOLD}What do you want to do?${NC}`);
   console.log('');
-  console.log(`  ${MAGENTA}[1]${NC} Codex CLI     → .codex.md`);
-  console.log(`  ${MAGENTA}[2]${NC} Cursor        → .cursorrules`);
-  console.log(`  ${MAGENTA}[3]${NC} Claude Code   → CLAUDE.md`);
-  console.log(`  ${MAGENTA}[4]${NC} All           → generate all`);
+  console.log(`  ${MAGENTA}[1]${NC} Learn Project   → bootstrap .palbox/ (Lyleen)`);
+  console.log(`  ${MAGENTA}[2]${NC} Codex CLI       → .codex.md`);
+  console.log(`  ${MAGENTA}[3]${NC} Cursor          → .cursorrules`);
+  console.log(`  ${MAGENTA}[4]${NC} Claude Code     → CLAUDE.md`);
+  console.log(`  ${MAGENTA}[5]${NC} All Agents      → generate all configs`);
   console.log('');
 
-  const choice = await ask(`  Choose [1-4]: `);
+  const choice = await ask(`  Choose [1-5]: `);
   console.log('');
 
+  if (choice === '1') {
+    bootstrapPalbox();
+    installSkills();
+    console.log(`\n  ${GREEN}✅ Done!${NC} .palbox/ created. Run again to generate agent configs.\n`);
+    process.exit(0);
+  }
+
   const agents = [];
-  if (choice === '1') agents.push('codex');
-  else if (choice === '2') agents.push('cursor');
-  else if (choice === '3') agents.push('claude');
-  else if (choice === '4') agents.push('codex', 'cursor', 'claude');
+  if (choice === '2') agents.push('codex');
+  else if (choice === '3') agents.push('cursor');
+  else if (choice === '4') agents.push('claude');
+  else if (choice === '5') agents.push('codex', 'cursor', 'claude');
   else { console.log('  Invalid choice. Exiting.'); process.exit(1); }
 
   for (const agent of agents) {
@@ -57,6 +65,178 @@ async function main() {
   console.log(`\n  ${GREEN}✅ Done!${NC} Restart Hermes Agent to load skills.\n`);
 }
 
+function bootstrapPalbox() {
+  const cwd = process.cwd();
+  const palbox = path.join(cwd, '.palbox');
+
+  if (fs.existsSync(palbox)) {
+    console.log(`  ${YELLOW}⚠${NC}  .palbox/ already exists. Skipping bootstrap.\n`);
+    console.log('  To re-analyze, delete .palbox/ and run again.\n');
+    return;
+  }
+
+  console.log(`  ${CYAN}🔍 Analyzing project...${NC}\n`);
+
+  // Detect tech stack
+  const files = fs.readdirSync(cwd);
+  const hasFile = name => files.includes(name);
+  let language = 'Unknown';
+  let framework = '';
+  let pkgManager = '';
+
+  if (hasFile('package.json')) {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    language = 'TypeScript/JavaScript';
+    framework = pkg.dependencies?.next ? 'Next.js' :
+                pkg.dependencies?.react ? 'React' :
+                pkg.dependencies?.express ? 'Express' :
+                pkg.dependencies?.fastify ? 'Fastify' : 'Node.js';
+    pkgManager = hasFile('pnpm-lock.yaml') ? 'pnpm' :
+                 hasFile('yarn.lock') ? 'yarn' : 'npm';
+  } else if (hasFile('requirements.txt') || hasFile('pyproject.toml')) {
+    language = 'Python';
+    framework = hasFile('pyproject.toml') ? 'Poetry' : 'pip';
+    if (fs.existsSync(path.join(cwd, 'pyproject.toml'))) {
+      try {
+        const toml = fs.readFileSync(path.join(cwd, 'pyproject.toml'), 'utf8');
+        if (toml.includes('fastapi')) framework = 'FastAPI';
+        else if (toml.includes('django')) framework = 'Django';
+        else if (toml.includes('flask')) framework = 'Flask';
+      } catch {}
+    }
+  } else if (hasFile('go.mod')) {
+    language = 'Go';
+    framework = 'Go modules';
+  } else if (hasFile('Cargo.toml')) {
+    language = 'Rust';
+    framework = 'Cargo';
+  }
+
+  // Detect project name
+  let projectName = path.basename(cwd);
+  if (hasFile('package.json')) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+      if (pkg.name) projectName = pkg.name;
+    } catch {}
+  }
+
+  // Get git info
+  let gitContributors = '';
+  try {
+    const { execSync } = require('child_process');
+    gitContributors = execSync('git log --format="%an" | sort | uniq -c | sort -rn | head -3', { cwd, encoding: 'utf8' }).trim();
+  } catch {}
+
+  // Create palbox structure
+  fs.mkdirSync(path.join(palbox, 'flows'), { recursive: true });
+  fs.mkdirSync(path.join(palbox, 'history'), { recursive: true });
+  fs.mkdirSync(path.join(palbox, 'plans'), { recursive: true });
+
+  const date = new Date().toISOString().split('T')[0];
+
+  // README.md
+  fs.writeFileSync(path.join(palbox, 'README.md'), `# ${projectName}
+
+**Generated:** ${date}
+**Bootstrapped by:** Lyleen (Palskills)
+
+## Overview
+[Project description — update this]
+
+## Tech Stack
+- **Language:** ${language}
+- **Framework:** ${framework}${pkgManager ? `\n- **Package Manager:** ${pkgManager}` : ''}
+
+## Project Goal
+[What problem does this project solve? — update this]
+
+## Quick Start
+[How to run the project — update this]
+
+## Knowledge Graph
+- [[architecture]] — folder structure and design patterns
+- [[methods]] — coding conventions and standards
+- [[flows/]] — feature workflow documentation
+- [[history/]] — past development sessions
+`);
+
+  // architecture.md
+  let dirTree = '';
+  try {
+    const result = fs.readdirSync(cwd, { withFileTypes: true })
+      .filter(d => d.isDirectory() && !d.name.startsWith('.') && d.name !== 'node_modules' && d.name !== '__pycache__')
+      .map(d => `├── ${d.name}/`)
+      .join('\n');
+    dirTree = result || '(empty)';
+  } catch { dirTree = '(unknown)'; }
+
+  fs.writeFileSync(path.join(palbox, 'architecture.md'), `# Architecture
+
+**Last Updated:** ${date}
+
+## Folder Structure
+\`\`\`
+${projectName}/
+${dirTree}
+\`\`\`
+
+## Design Patterns
+[Detected patterns — update this]
+
+## Key Modules
+| Module | Responsibility | Key Files |
+|--------|---------------|-----------|
+| ... | ... | ... |
+
+## Data Flow
+[How data moves through the system]
+
+## Related
+- [[methods]] — how we build
+- [[README]] — project overview
+`);
+
+  // methods.md
+  fs.writeFileSync(path.join(palbox, 'methods.md'), `# Development Methods
+
+**Last Updated:** ${date}
+
+## Coding Conventions
+[Detected from codebase — update this]
+
+## Testing Strategy
+[Detected from test files — update this]
+
+## Git Workflow
+${gitContributors ? `\n**Top Contributors:**\n\`\`\`\n${gitContributors}\n\`\`\`` : '[Run git log to populate]'}
+
+## Code Review Standards
+- SOLID principles enforced
+- Single Responsibility Pattern required
+- All code in English
+
+## Related
+- [[architecture]] — where things live
+- [[README]] — project overview
+`);
+
+  console.log(`  ${GREEN}✓${NC} .palbox/README.md`);
+  console.log(`  ${GREEN}✓${NC} .palbox/architecture.md`);
+  console.log(`  ${GREEN}✓${NC} .palbox/methods.md`);
+  console.log(`  ${GREEN}✓${NC} .palbox/flows/`);
+  console.log(`  ${GREEN}✓${NC} .palbox/history/`);
+  console.log(`  ${GREEN}✓${NC} .palbox/plans/`);
+  console.log('');
+  console.log(`  Detected: ${language} + ${framework}`);
+  if (gitContributors) console.log(`  Git history found`);
+  console.log('');
+  console.log(`  Next steps:`);
+  console.log(`    1. Edit .palbox/README.md with project details`);
+  console.log(`    2. Run 'palskills' again to generate agent configs`);
+  console.log(`    3. Or use Hermes skills: "Load lyleen, build feature X"`);
+}
+
 function generate(agent) {
   const cwd = process.cwd();
 
@@ -80,155 +260,159 @@ function generate(agent) {
 }
 
 function codexRules() {
-  return `# Codex Rules — Palskills
-# Generated by palskills CLI
-
-## SOLID Principles (Enforced)
-1. **Single Responsibility:** Every class/module/function has exactly ONE reason to change.
-2. **Open/Closed:** Extend via inheritance/composition, never modify existing code.
-3. **Liskov Substitution:** Subtypes must be fully substitutable for their base types.
-4. **Interface Segregation:** Small, focused interfaces. No client depends on unused methods.
-5. **Dependency Inversion:** Depend on abstractions. Inject dependencies.
-
-## SRP Enforcement
-- Repository → data access ONLY
-- Service → business logic ONLY
-- Validator → validation rules ONLY
-- Model → data structures ONLY
-- If a class mixes these, REFACTOR immediately.
-
-## Code Structure
-- No file exceeds 200 lines without strong justification.
-- Business logic → services/. Data access → repositories/. Validation → validators/.
-- Models are pure data structures — no methods, no logic.
-
-## Language
-ALL code, comments, docstrings, variable names, and commit messages MUST be in English.
-
-## Git
-- One commit per logical change.
-- Conventional commits: feat(scope): description / fix(scope): description / test(scope): description
-
-## Palbox Knowledge Graph (CRITICAL)
-### Before you start ANY task
-1. **Check if .palbox/ exists.** If not, the project has not been bootstrapped yet.
-2. **Read the core nodes:**
-   - .palbox/README.md — project identity, tech stack, goals
-   - .palbox/architecture.md — folder structure, design patterns, key modules
-   - .palbox/methods.md — coding conventions, testing strategy, git workflow
-3. **Search for related past work:**
-   - Search for keywords in .palbox/flows/ and .palbox/history/
-   - Follow wikilinks to discover connected context
-4. **Read relevant flows** in .palbox/flows/ — they document how features work end-to-end
-5. **Read relevant history** in .palbox/history/ — past plans, executions, lessons learned
-
-### After you complete a task
-- Record what you did. The Palskills system (Panthalus) will create a .palbox/history/YYYY-MM-DD-feature.md node with wikilinks to related entries.
-- If you discovered new patterns, conventions, or pitfalls, note them — they enrich the graph.
-`;
+  return palskillsAgentConfig('Codex');
 }
 
 function cursorRules() {
-  return `# Cursor Rules — Palskills
-# Generated by palskills CLI
-
-## Core Principles
-You are working in a project managed by the Palskills development system.
-Always follow these rules.
-
-### SOLID
-1. **S** — Single Responsibility: one class, one reason to change.
-2. **O** — Open/Closed: extend, don't modify.
-3. **L** — Liskov Substitution: subtypes fully substitutable.
-4. **I** — Interface Segregation: small interfaces, no fat abstractions.
-5. **D** — Dependency Inversion: depend on abstractions, inject deps.
-
-### SRP (Single Responsibility Pattern)
-- Repository classes: data access ONLY
-- Service classes: business logic ONLY
-- Validator classes: validation rules ONLY
-- Model classes: data structures ONLY
-- If any module mixes these, REFACTOR.
-
-### Language
-ALL code, comments, docs, variable names, and commit messages MUST be in English.
-
-### Git
-- One commit per logical change
-- Conventional commits format: feat(scope): / fix(scope): / test(scope):
-
-### Project Context — Palbox Knowledge Graph
-Before you start ANY task:
-1. **Check if .palbox/ exists.** Read the core nodes:
-   - .palbox/README.md — project identity, stack, goals
-   - .palbox/architecture.md — folder structure, patterns, key modules
-   - .palbox/methods.md — conventions, testing, git workflow
-2. **Search .palbox/flows/ and .palbox/history/** for related past work.
-3. **Follow wikilinks** — they connect related nodes in the knowledge graph.
-
-After completing work:
-- The Palskills system (Panthalus) records to .palbox/history/ with bi-directional links.
-
-### Code Quality
-- No file exceeds 200 lines without strong justification.
-- Every function has a clear, single purpose.
-- Prefer composition over inheritance.
-- Write tests for all new logic.
-`;
+  return palskillsAgentConfig('Cursor');
 }
 
 function claudeRules() {
-  return `# CLAUDE.md — Palskills
-# Generated by palskills CLI
-
-## Who You Are
-You are an AI coding assistant working in a Palskills-managed project.
-You follow SOLID principles, Single Responsibility Pattern, and write all code in English.
-
-## SOLID (Strict)
-1. **Single Responsibility:** Every class, module, and function has exactly ONE reason to change.
-2. **Open/Closed:** Open for extension via inheritance/composition, closed for modification.
-3. **Liskov Substitution:** Derived classes must be fully substitutable for base classes.
-4. **Interface Segregation:** Many small, focused interfaces — no fat abstractions.
-5. **Dependency Inversion:** Depend on abstractions, inject dependencies. Never instantiate collaborators in business logic.
-
-## SRP (Single Responsibility Pattern)
-- Repository classes → data access ONLY
-- Service classes → business logic ONLY
-- Validator classes → validation rules ONLY
-- Model classes → data structures ONLY (no methods, no logic)
-- If a class mixes these concerns, REFACTOR immediately.
-
-## Code Structure
-\`\`\`
-src/
-├── models/      # Pure data structures
-├── repositories/ # Data access layer
-├── services/    # Business logic
-├── validators/  # Validation rules
-└── interfaces/  # Abstract bases & protocols
-\`\`\`
+  return palskillsAgentConfig('Claude Code');
+}
 
-## Language
-ALL code, comments, docstrings, variable names, function names, and commit messages MUST be in English.
-
-## Git
-- One commit per logical change.
-- Conventional commits: feat(scope): / fix(scope): / test(scope):
-- Never commit generated files, node_modules, or secrets.
-
-## Project Context — Palbox Knowledge Graph
-Before starting any task:
-1. Check if .palbox/ exists. Read the core nodes:
-   - .palbox/README.md — project identity, stack, goals
-   - .palbox/architecture.md — folder structure, patterns, key modules
-   - .palbox/methods.md — conventions, testing, git workflow
-2. Search .palbox/flows/ and .palbox/history/ for related past work.
-3. Follow wikilinks — they connect related nodes in the knowledge graph.
-
-After completing work:
-- The Palskills system (Panthalus) records your session to .palbox/history/ with bi-directional wikilinks.
-- If you discovered patterns, pitfalls, or conventions worth preserving, note them.
+function palskillsAgentConfig(agentName) {
+  return `# Palskills — Multi-Mode AI Development System
+# Generated for ${agentName}
+#
+# HOW TO USE: Start your prompt with the skill name.
+#   "Lyleen: learn the ftz export module"
+#   "Jetdragon: plan a forgot-password feature"
+#   "Anubis: implement the approved plan"
+#   "Panthalus: record this session"
+#
+# Or let Astralym orchestrate the full flow:
+#   "Astralym: build a user dashboard"
+
+---
+
+## SKILL MODES
+
+You are an AI coding agent with **5 selectable skill modes**. When the user starts a prompt with a skill name followed by a colon, activate that mode immediately.
+
+---
+
+### LYLEEN — Palbox Knowledge Graph
+**Trigger:** Prompt starts with "Lyleen:" or "lyleen:"
+**Role:** Read and bootstrap the project knowledge graph.
+
+#### If .palbox/ does NOT exist — BOOTSTRAP:
+1. Scan the project structure:
+   - Read package.json / requirements.txt / go.mod / Cargo.toml to detect tech stack
+   - List top-level directories (skip .git, node_modules, __pycache__)
+   - Read existing README.md if present
+   - Check git log for contributors and recent activity
+   - Find testing patterns (files matching *test*, *spec*)
+2. Create .palbox/ with this structure:
+   - .palbox/README.md — project name, tech stack, goals, quick start, knowledge graph links
+   - .palbox/architecture.md — folder structure tree, design patterns, key modules table, data flow
+   - .palbox/methods.md — coding conventions, testing strategy, git workflow, code review standards
+3. Create subdirectories: flows/, history/, plans/
+4. Every .md file MUST include wikilinks ([[other-file]]) to connect the graph
+5. Report: "Palbox bootstrapped. N files analyzed. Detected: [tech stack]."
+
+#### If .palbox/ EXISTS — CONTEXT RETRIEVAL:
+1. Read .palbox/README.md, .palbox/architecture.md, .palbox/methods.md
+2. Search .palbox/flows/ and .palbox/history/ for keywords in the user query
+3. Extract all [[wikilinks]] from matching files. Follow them 1-2 hops deep.
+4. Return a "Context Subgraph" summary:
+   - Seed nodes (direct matches)
+   - 1-hop neighbors (linked context)
+   - 2-hop neighbors (extended context)
+   - Relevant conventions and past decisions
+5. If nothing relevant found, say so clearly.
+
+---
+
+### JETDRAGON — Planner
+**Trigger:** Prompt starts with "Jetdragon:" or "jetdragon:"
+**Role:** Create detailed, actionable implementation plans. Ask questions until the plan is crystal clear.
+
+1. First, act like Lyleen to gather palbox context (read core docs, search for related work)
+2. Generate a plan saved to .palbox/plans/YYYY-MM-DD-feature-name.md:
+   - Overview (2-3 sentences)
+   - Scope: in scope / out of scope
+   - Tasks ordered by dependency, each with: what, files to touch, verification steps
+   - Architecture notes: patterns to use, SOLID focus
+   - Risks and mitigations
+   - Use [[wikilinks]] to reference .palbox/ entries
+3. If ANYTHING is ambiguous, ASK the user:
+   - Scope: "Should this also handle X?"
+   - Design: "Class-based or functional?"
+   - Edge cases: "What happens when input is empty?"
+   - Integration: "Does this touch the existing auth module?"
+   - Priority: "Which task first?"
+4. Iterate: user responds → update plan → ask more → repeat
+5. When the user says "Gas", "Go", "Execute", or "Approved":
+   - Update status to APPROVED
+   - Output: "Plan approved. Ready for Anubis."
+   - Include the full plan for the next step
+
+---
+
+### ANUBIS — Developer
+**Trigger:** Prompt starts with "Anubis:" or "anubis:"
+**Role:** Execute an approved plan following SOLID + SRP. All code in English.
+
+1. Read the approved plan from .palbox/plans/ or from the provided context
+2. Execute task by task, in order:
+   - Read existing files before modifying
+   - Write code following SOLID + SRP
+   - Write tests if the project has testing patterns
+   - Verify acceptance criteria
+3. **SOLID (strict):**
+   - Single Responsibility: one class, one reason to change
+   - Open/Closed: extend, never modify existing
+   - Liskov Substitution: subtypes fully substitutable
+   - Interface Segregation: small focused interfaces
+   - Dependency Inversion: depend on abstractions, inject deps
+4. **SRP Separation:**
+   - Repository → data access ONLY
+   - Service → business logic ONLY
+   - Validator → validation rules ONLY
+   - Model → data structures ONLY
+   - If a class mixes these, REFACTOR immediately
+5. **Language:** ALL code, comments, docstrings, variable names, and commit messages MUST be in English
+6. **Git:** one commit per logical change. Conventional commits format
+7. After all tasks complete, output a summary: files changed, commits made, verification results
+
+---
+
+### PANTHALUS — Archivist
+**Trigger:** Prompt starts with "Panthalus:" or "panthalus:"
+**Role:** Record the session to the .palbox/ knowledge graph with bi-directional links.
+
+1. Collect artifacts: the plan, git diff summary, commit messages, decisions made
+2. Create .palbox/history/YYYY-MM-DD-feature-name.md:
+   - Links section with [[wikilinks]] to related entries (flows, architecture, past history)
+   - Original prompt
+   - Plan (full, not summarized)
+   - Execution: files changed, commits
+   - Key decisions table
+   - Lessons learned (pitfalls, discoveries, patterns)
+3. **Create backlinks:** For EVERY [[wikilink]] in the history entry, go to that file and add a reference back:
+   - Add "## Related Sessions" section if it does not exist
+   - Append "- [[history/YYYY-MM-DD-feature]] — [one-line summary]"
+4. Update core docs only if structural knowledge changed (new modules, new conventions)
+5. Report graph stats: new node, edges created, nodes enriched, total nodes/edges
+
+---
+
+### ASTRALYM — Orchestrator
+**Trigger:** Prompt starts with "Astralym:" or "astralym:"
+**Role:** Run the full development pipeline automatically.
+
+1. **CHECK_GRAPH** — Act as Lyleen: bootstrap .palbox/ if missing, or retrieve context subgraph
+2. **PLANNING** — Act as Jetdragon: create plan, ask clarifying questions, wait for "Gas"
+3. **DEVELOPING** — Act as Anubis: execute the approved plan with SOLID + SRP
+4. **RECORDING** — Act as Panthalus: record everything to .palbox/ with backlinks
+5. **DONE** — Report summary with graph stats
+
+---
+
+## DEFAULT MODE
+
+When no specific skill is triggered, act as **Anubis** by default — write code following SOLID + SRP, all output in English. Before starting any task, quickly check .palbox/ for relevant context (like Lyleen, but minimal — 30 seconds max).
 `;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palskills",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "AI-powered development pipeline — 5 Hermes Agent skills orchestrated as a knowledge graph",
   "keywords": [
     "hermes-agent",