palskills 1.0.4 → 1.0.6

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/skills/`);
+  console.log(`  ${MAGENTA}[3]${NC} Cursor          → .cursor/skills/`);
+  console.log(`  ${MAGENTA}[4]${NC} Claude Code     → .claude/skills/`);
+  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,179 +65,298 @@ async function main() {
   console.log(`\n  ${GREEN}✅ Done!${NC} Restart Hermes Agent to load skills.\n`);
 }
 
-function generate(agent) {
+function bootstrapPalbox() {
   const cwd = process.cwd();
+  const palbox = path.join(cwd, '.palbox');
 
-  if (agent === 'codex') {
-    const file = path.join(cwd, '.codex.md');
-    fs.writeFileSync(file, codexRules());
-    console.log(`  ${GREEN}✓${NC} .codex.md`);
+  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;
   }
 
-  if (agent === 'cursor') {
-    const file = path.join(cwd, '.cursorrules');
-    fs.writeFileSync(file, cursorRules());
-    console.log(`  ${GREEN}✓${NC} .cursorrules`);
+  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';
   }
 
-  if (agent === 'claude') {
-    const file = path.join(cwd, 'CLAUDE.md');
-    fs.writeFileSync(file, claudeRules());
-    console.log(`  ${GREEN}✓${NC} CLAUDE.md`);
+  // 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 {}
   }
-}
 
-function codexRules() {
-  return `# Codex Rules — Palskills
-# Generated by palskills CLI
+  // 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 {}
 
-## 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.
+  // 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 });
 
-## 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.
-`;
-}
+  const date = new Date().toISOString().split('T')[0];
 
-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.
-`;
-}
+  // README.md
+  fs.writeFileSync(path.join(palbox, 'README.md'), `# ${projectName}
 
-function claudeRules() {
-  return `# CLAUDE.md — Palskills
-# Generated by palskills CLI
+**Generated:** ${date}
+**Bootstrapped by:** Lyleen (Palskills)
 
-## 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.
+## Overview
+[Project description — update this]
 
-## 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
+## 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
 \`\`\`
-src/
-├── models/      # Pure data structures
-├── repositories/ # Data access layer
-├── services/    # Business logic
-├── validators/  # Validation rules
-└── interfaces/  # Abstract bases & protocols
+${projectName}/
+${dirTree}
 \`\`\`
 
-## 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.
-`;
+## 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();
+  const skillNames = ['lyleen', 'jetdragon', 'anubis', 'panthalus', 'astralym'];
+
+  let dir;
+  if (agent === 'codex') dir = path.join(cwd, '.codex', 'skills');
+  else if (agent === 'cursor') dir = path.join(cwd, '.cursor', 'skills');
+  else if (agent === 'claude') dir = path.join(cwd, '.claude', 'skills');
+
+  fs.mkdirSync(dir, { recursive: true });
+
+  for (const name of skillNames) {
+    const file = path.join(dir, `${name}.md`);
+    fs.writeFileSync(file, skillContent(agent, name));
+    console.log(`  ${GREEN}✓${NC} ${dir}/${name}.md`);
+  }
+}
+
+function skillContent(agent, skill) {
+  const skills = {
+    lyleen: `# Lyleen — Palbox Knowledge Graph
+**Agent:** ${agent === 'codex' ? 'Codex' : agent === 'cursor' ? 'Cursor' : 'Claude Code'}
+
+## Role
+Read and bootstrap the project knowledge graph (.palbox/).
+
+## If .palbox/ does NOT exist — BOOTSTRAP:
+1. Scan project: read package.json/requirements.txt/go.mod, list dirs, check git log, find tests
+2. Create .palbox/README.md — project name, tech stack, goals, [[links]]
+3. Create .palbox/architecture.md — folder tree, design patterns, key modules
+4. Create .palbox/methods.md — conventions, testing, git workflow
+5. Create .palbox/flows/, .palbox/history/, .palbox/plans/
+6. Report: "Palbox bootstrapped. N files. Detected: [stack]."
+
+## If .palbox/ EXISTS — RETRIEVE:
+1. Read README.md, architecture.md, methods.md
+2. Search flows/ and history/ for user keywords
+3. Extract [[wikilinks]], follow 1-2 hops
+4. Return context subgraph: seeds → 1-hop → 2-hop → conventions
+`,
+    jetdragon: `# Jetdragon — Planner
+**Agent:** ${agent === 'codex' ? 'Codex' : agent === 'cursor' ? 'Cursor' : 'Claude Code'}
+
+## Role
+Create detailed implementation plans. Ask questions until clear.
+
+## Process
+1. Gather palbox context (read core docs, search related history)
+2. Generate plan → .palbox/plans/YYYY-MM-DD-feature.md with [[wikilinks]]
+3. If ambiguous, ASK: scope, design, edge cases, integration, priority
+4. Iterate until user says "Gas", "Go", "Execute"
+5. Finalize as APPROVED, hand off to Anubis
+
+## Plan Template
+- Overview, Scope (in/out), Tasks (ordered, with files + verification)
+- Architecture notes, SOLID focus, Risks & Mitigations
+- All references use [[wikilinks]] to .palbox/ entries
+`,
+    anubis: `# Anubis — Developer
+**Agent:** ${agent === 'codex' ? 'Codex' : agent === 'cursor' ? 'Cursor' : 'Claude Code'}
+
+## Role
+Execute approved plans. SOLID + SRP enforced. English only.
+
+## SOLID (Strict)
+- **S**: One class, one reason to change
+- **O**: Extend, never modify existing
+- **L**: Subtypes fully substitutable
+- **I**: Small focused interfaces
+- **D**: Depend on abstractions, inject deps
+
+## SRP Separation
+- Repository → data access ONLY
+- Service → business logic ONLY
+- Validator → validation rules ONLY
+- Model → data structures ONLY
+
+## Rules
+- ALL code, comments, docstrings, commits in English
+- One commit per logical change (conventional commits)
+- Read existing files before modifying
+- Write tests if project has testing patterns
+`,
+    panthalus: `# Panthalus — Archivist
+**Agent:** ${agent === 'codex' ? 'Codex' : agent === 'cursor' ? 'Cursor' : 'Claude Code'}
+
+## Role
+Record sessions to .palbox/ with bi-directional [[wikilinks]].
+
+## Process
+1. Collect: plan, git diff, commits, decisions, lessons
+2. Create .palbox/history/YYYY-MM-DD-feature.md with [[wikilinks]]
+3. For EVERY link, add backlink to the target file ("Related Sessions")
+4. Update core docs (architecture/methods) only if structure changed
+5. Report graph stats: nodes, edges, enriched
+
+## History Entry Template
+- Links ([[flows/]], [[architecture]], [[history/]])
+- Original prompt, Plan, Execution (files + commits)
+- Key Decisions table, Lessons Learned (pitfalls, discoveries)
+- Backlinks section
+`,
+    astralym: `# Astralym — Orchestrator
+**Agent:** ${agent === 'codex' ? 'Codex' : agent === 'cursor' ? 'Cursor' : 'Claude Code'}
+
+## Role
+Run the full development pipeline automatically.
+
+## Pipeline
+1. **CHECK_GRAPH** → Lyleen: bootstrap or retrieve context
+2. **PLANNING** → Jetdragon: create plan, ask questions, wait for "Gas"
+3. **DEVELOPING** → Anubis: execute with SOLID + SRP
+4. **RECORDING** → Panthalus: record with backlinks
+5. **DONE** → Summary with graph stats
+
+## Usage
+User says "Astralym: build feature X" → full pipeline runs.
+`
+  };
+  return skills[skill] || '';
 }
 
 function installSkills() {

package/package.json

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