agent-skill-kit 3.9.135

package/.agent/scripts/compile-agents.ts

@@ -0,0 +1,237 @@
+// @ts-nocheck
+/**
+ * Compile AGENTS.md — PikaKit
+ * Compiles all rule files in a skill's rules/ directory into a single AGENTS.md.
+ *
+ * Usage:
+ *   npx tsx compile-agents.ts                    # Compile ALL skills missing AGENTS.md
+ *   npx tsx compile-agents.ts ai-artist          # Compile specific skill
+ *   npx tsx compile-agents.ts --force             # Recompile ALL skills (overwrite existing)
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SKILLS_DIR = path.resolve(__dirname, '../skills');
+
+const args = process.argv.slice(2);
+const force = args.includes('--force');
+const targetSkill = args.find(a => !a.startsWith('--'));
+
+function getSkillsToCompile(): string[] {
+  if (targetSkill) return [targetSkill];
+
+  const dirs = fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  return dirs.filter(skill => {
+    const rulesDir = path.join(SKILLS_DIR, skill, 'rules');
+    const agentsMd = path.join(SKILLS_DIR, skill, 'AGENTS.md');
+    const hasRules = fs.existsSync(rulesDir);
+    const hasAgents = fs.existsSync(agentsMd);
+
+    if (!hasRules) return false;
+
+    // Count non-meta rule files
+    const ruleFiles = fs.readdirSync(rulesDir)
+      .filter(f => f.endsWith('.md') && !f.startsWith('_'));
+
+    if (ruleFiles.length === 0) return false;
+
+    return force || !hasAgents;
+  });
+}
+
+function readSections(skillDir: string): Map<string, { impact: string; description: string }> {
+  const sectionsPath = path.join(skillDir, 'rules', '_sections.md');
+  const sections = new Map<string, { impact: string; description: string }>();
+
+  if (!fs.existsSync(sectionsPath)) return sections;
+
+  const content = fs.readFileSync(sectionsPath, 'utf-8');
+  const sectionRegex = /##\s+\d+\.\s+(.+?)\s+\((\w[\w-]*)\)\s*\n+\*\*Impact:\*\*\s*(\w+)\s*\n\*\*Description:\*\*\s*(.+)/g;
+  let match;
+
+  while ((match = sectionRegex.exec(content)) !== null) {
+    sections.set(match[2], {
+      impact: match[3],
+      description: match[4].trim()
+    });
+  }
+
+  return sections;
+}
+
+function readSkillFrontmatter(skillDir: string): { name: string; description: string; version: string } {
+  const skillMd = path.join(skillDir, 'SKILL.md');
+  const content = fs.readFileSync(skillMd, 'utf-8');
+  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+
+  let name = path.basename(skillDir);
+  let description = '';
+  let version = '3.9.121';
+
+  if (fmMatch) {
+    const fm = fmMatch[1];
+    const nameMatch = fm.match(/name:\s*(.+)/);
+    if (nameMatch) name = nameMatch[1].trim();
+
+    const versionMatch = fm.match(/version:\s*['"]?([^'"]+)['"]?/);
+    if (versionMatch) version = versionMatch[1].trim();
+
+    const descMatch = fm.match(/description:\s*>-\s*\r?\n((?:\s+.*\r?\n)*)/);
+    if (descMatch) {
+      description = descMatch[1].replace(/^\s+/gm, '').trim();
+    } else {
+      const singleDesc = fm.match(/description:\s*(.+)/);
+      if (singleDesc) description = singleDesc[1].trim();
+    }
+  }
+
+  return { name, description, version };
+}
+
+function compileAgentsMd(skill: string): void {
+  const skillDir = path.join(SKILLS_DIR, skill);
+  const rulesDir = path.join(skillDir, 'rules');
+
+  const { name, description, version } = readSkillFrontmatter(skillDir);
+  const sections = readSections(skillDir);
+
+  // Read all rule files (excluding _ prefixed)
+  const ruleFiles = fs.readdirSync(rulesDir)
+    .filter(f => f.endsWith('.md') && !f.startsWith('_'))
+    .sort();
+
+  // Group rules by prefix
+  const ruleGroups = new Map<string, { filename: string; content: string }[]>();
+
+  for (const file of ruleFiles) {
+    const content = fs.readFileSync(path.join(rulesDir, file), 'utf-8');
+    // Strip frontmatter from rule content
+    const bodyMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n([\s\S]*)$/);
+    const body = bodyMatch ? bodyMatch[1].trim() : content.trim();
+
+    // Determine prefix (group key)
+    const prefix = file.replace(/\.md$/, '').replace(/-[^-]+$/, '') || 'general';
+
+    if (!ruleGroups.has(prefix)) {
+      ruleGroups.set(prefix, []);
+    }
+    ruleGroups.get(prefix)!.push({ filename: file, content: body });
+  }
+
+  // Build display name
+  const displayName = name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+
+  // Count total rules
+  const totalRules = ruleFiles.length;
+  const totalCategories = ruleGroups.size;
+
+  // Build AGENTS.md
+  const lines: string[] = [];
+
+  lines.push(`# ${displayName}`);
+  lines.push('');
+  lines.push(`**Version ${version}**`);
+  lines.push('Engineering');
+  lines.push(`${new Date().toLocaleString('en-US', { month: 'long', year: 'numeric' })}`);
+  lines.push('');
+  lines.push('> **Note:**');
+  lines.push(`> This document is for agents and LLMs to follow when working on ${name} tasks.`);
+  lines.push('> Optimized for automation and consistency by AI-assisted workflows.');
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+  lines.push('## Abstract');
+  lines.push('');
+  lines.push(`This document compiles ${totalRules} rules across ${totalCategories} categories for the ${displayName} skill. ${description.split('.')[0]}.`);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  // Table of Contents
+  lines.push('## Table of Contents');
+  lines.push('');
+  let sectionNum = 0;
+  for (const [prefix, rules] of ruleGroups) {
+    sectionNum++;
+    const sectionInfo = sections.get(prefix);
+    const impact = sectionInfo?.impact || 'MEDIUM';
+    const sectionTitle = prefix.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    lines.push(`${sectionNum}. [${sectionTitle}](#${sectionNum}-${prefix}) — **${impact}**`);
+    let ruleNum = 0;
+    for (const rule of rules) {
+      ruleNum++;
+      const ruleTitle = rule.filename.replace('.md', '').split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+      lines.push(`   - ${sectionNum}.${ruleNum} [${ruleTitle}](#${sectionNum}${ruleNum}-${rule.filename.replace('.md', '')})`);
+    }
+  }
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  // Content sections
+  sectionNum = 0;
+  for (const [prefix, rules] of ruleGroups) {
+    sectionNum++;
+    const sectionInfo = sections.get(prefix);
+    const impact = sectionInfo?.impact || 'MEDIUM';
+    const sectionTitle = prefix.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+
+    lines.push(`## ${sectionNum}. ${sectionTitle}`);
+    lines.push('');
+    lines.push(`**Impact: ${impact}**`);
+    if (sectionInfo?.description) {
+      lines.push('');
+      lines.push(sectionInfo.description);
+    }
+    lines.push('');
+
+    let ruleNum = 0;
+    for (const rule of rules) {
+      ruleNum++;
+      lines.push('');
+      // The rule content already has its own headers, just include it
+      lines.push(rule.content);
+      lines.push('');
+    }
+
+    lines.push('---');
+    lines.push('');
+  }
+
+  lines.push(`⚡ PikaKit v${version}`);
+  lines.push('');
+
+  const output = lines.join('\n');
+  const outputPath = path.join(skillDir, 'AGENTS.md');
+  fs.writeFileSync(outputPath, output, 'utf-8');
+  console.log(`✅ Compiled ${skill}/AGENTS.md (${totalRules} rules, ${totalCategories} categories, ${output.length} bytes)`);
+}
+
+// Execute
+const skills = getSkillsToCompile();
+
+if (skills.length === 0) {
+  console.log('\n✨ All skills already have AGENTS.md!');
+  process.exit(0);
+}
+
+console.log(`\n🔧 Compiling AGENTS.md for ${skills.length} skills...\n`);
+
+let compiled = 0;
+for (const skill of skills) {
+  try {
+    compileAgentsMd(skill);
+    compiled++;
+  } catch (e: any) {
+    console.error(`❌ Failed to compile ${skill}: ${e.message}`);
+  }
+}
+
+console.log(`\n🎉 Done! Compiled ${compiled}/${skills.length} AGENTS.md files.`);

package/.agent/scripts/fix_skills.ts

@@ -0,0 +1,49 @@
+// @ts-nocheck
+/**
+ * Fix Skills — PikaKit
+ * Extracts and injects skills list into workflow YAML frontmatter.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const dir = 'C:/Users/sofma/Desktop/agent-skill-kit/.agent/workflows';
+const files = fs.readdirSync(dir).filter((f: string) => f.endsWith('.md'));
+
+for (const f of files) {
+  let txt = fs.readFileSync(path.join(dir, f), 'utf8');
+
+  const regex = /`([a-z0-9-]+)`/g;
+  let match: RegExpExecArray | null;
+  const allSkills = new Set<string>();
+
+  const skillLines = txt.match(/SKILLS.*|Skills Loaded.*/gi);
+  if (skillLines) {
+    const skillsSectionIdx = txt.toLowerCase().indexOf('skills loaded');
+    if (skillsSectionIdx > -1) {
+      const remainingTxt = txt.slice(skillsSectionIdx);
+      while ((match = regex.exec(remainingTxt)) !== null) {
+        if (!['assessor', 'recovery', 'learner', 'critic', 'orchestrator'].includes(match[1])) {
+          allSkills.add(match[1]);
+        }
+      }
+    }
+
+    skillLines.forEach((line: string) => {
+      const r = /`([a-z0-9-]+)`/g;
+      let m: RegExpExecArray | null;
+      while ((m = r.exec(line)) !== null) {
+        if (!['assessor', 'recovery', 'learner', 'critic', 'orchestrator'].includes(m[1])) {
+          allSkills.add(m[1]);
+        }
+      }
+    });
+  }
+
+  if (allSkills.size > 0) {
+    const list = Array.from(allSkills).join(', ');
+    txt = txt.replace(/skills: \[.*\]/m, `skills: [${list}]`);
+    fs.writeFileSync(path.join(dir, f), txt, 'utf8');
+    console.log(`✅ Fixed skills for ${f}: ${list}`);
+  }
+}

package/.agent/scripts/session_manager.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Session Manager - PikaKit
+ * ==================================
+ * Analyzes project state, detects tech stack, tracks file statistics.
+ *
+ * Usage:
+ *   npx tsx session_manager.ts status [path]
+ *   npx tsx session_manager.ts info [path]
+ */
+
+import { readFile, readdir } from 'fs/promises';
+import { resolve, join } from 'path';
+import { parseArgs } from 'node:util';
+import { colors } from './utils/colors.ts';
+
+interface ProjectInfo {
+    name?: string;
+    version?: string;
+    stack: string[];
+    scripts: string[];
+    type?: string;
+    error?: string;
+}
+
+interface FileStats {
+    created: number;
+    modified: number;
+    total: number;
+}
+
+interface PackageJsonData {
+    name?: string;
+    version?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+}
+
+/**
+ * Get project root path
+ */
+function getProjectRoot(pathArg: string = '.'): string {
+    return resolve(pathArg);
+}
+
+/**
+ * Analyze package.json to detect tech stack
+ */
+async function analyzePackageJson(root: string): Promise<ProjectInfo> {
+    const pkgFile = join(root, 'package.json');
+
+    try {
+        const data: PackageJsonData = JSON.parse(await readFile(pkgFile, 'utf-8'));
+        const deps: Record<string, string> = { ...data.dependencies, ...data.devDependencies };
+
+        const stack: string[] = [];
+
+        // Framework detection
+        if (deps['next']) stack.push('Next.js');
+        else if (deps['react']) stack.push('React');
+        else if (deps['vue']) stack.push('Vue');
+        else if (deps['svelte']) stack.push('Svelte');
+        else if (deps['express']) stack.push('Express');
+        else if (deps['@nestjs/core'] || deps['nestjs']) stack.push('NestJS');
+
+        // Utility stack
+        if (deps['tailwindcss']) stack.push('Tailwind CSS');
+        if (deps['prisma']) stack.push('Prisma');
+        if (deps['typescript']) stack.push('TypeScript');
+
+        return {
+            name: data.name || 'unnamed',
+            version: data.version || '0.0.0',
+            stack,
+            scripts: Object.keys(data.scripts || {})
+        };
+    } catch (err: unknown) {
+        return {
+            type: 'unknown',
+            stack: [],
+            scripts: [],
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
+
+/**
+ * Count files in project (excluding common build/dependency dirs)
+ */
+async function countFiles(root: string): Promise<FileStats> {
+    const stats: FileStats = { created: 0, modified: 0, total: 0 };
+    const exclude = new Set([
+        '.git',
+        'node_modules',
+        '.next',
+        'dist',
+        'build',
+        '.agent',
+        '.gemini',
+        '__pycache__'
+    ]);
+
+    async function walk(dir: string): Promise<void> {
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (exclude.has(entry.name)) continue;
+
+                const fullPath = join(dir, entry.name);
+
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                } else {
+                    stats.total++;
+                }
+            }
+        } catch {
+            // Ignore permission errors
+        }
+    }
+
+    await walk(root);
+    return stats;
+}
+
+/**
+ * Detect project features/modules
+ */
+async function detectFeatures(root: string): Promise<string[]> {
+    const features: string[] = [];
+    const src = join(root, 'src');
+
+    try {
+        const possibleDirs = ['components', 'modules', 'features', 'app', 'pages', 'services'];
+
+        for (const dirName of possibleDirs) {
+            const dirPath = join(src, dirName);
+
+            try {
+                const entries = await readdir(dirPath, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        features.push(entry.name);
+                    }
+                }
+            } catch {
+                // Directory doesn't exist
+            }
+        }
+    } catch {
+        // src directory doesn't exist
+    }
+
+    return features.slice(0, 10); // Limit to top 10
+}
+
+/**
+ * Print project status
+ */
+async function printStatus(root: string): Promise<void> {
+    const info = await analyzePackageJson(root);
+    const stats = await countFiles(root);
+    const features = await detectFeatures(root);
+
+    console.log('\n=== Project Status ===');
+    console.log(`\n📁 Project: ${info.name || root}`);
+    console.log(`📂 Path: ${root}`);
+    console.log(`🏷️  Type: ${(info.stack.length > 0 ? info.stack : ['Generic']).join(', ')}`);
+    console.log(`📊 Status: Active`);
+
+    console.log('\n🔧 Tech Stack:');
+    for (const tech of info.stack) {
+        console.log(`   • ${tech}`);
+    }
+
+    console.log(`\n✅ Detected Modules/Features (${features.length}):`);
+    for (const feat of features) {
+        console.log(`   • ${feat}`);
+    }
+    if (features.length === 0) {
+        console.log('   (No distinct feature modules detected)');
+    }
+
+    console.log(`\n📄 Files: ${stats.total} total files tracked`);
+    console.log('\n====================\n');
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+    const { positionals } = parseArgs({
+        args: process.argv.slice(2),
+        allowPositionals: true,
+        options: {}
+    });
+
+    const command = positionals[0] || 'status';
+    const pathArg = positionals[1] || '.';
+
+    const root = getProjectRoot(pathArg);
+
+    if (command === 'status') {
+        await printStatus(root);
+    } else if (command === 'info') {
+        const info = await analyzePackageJson(root);
+        console.log(JSON.stringify(info, null, 2));
+    } else {
+        console.error(`Unknown command: ${command}`);
+        console.error('Usage: npx tsx session_manager.ts [status|info] [path]');
+        process.exit(1);
+    }
+}
+
+main().catch(err => {
+    console.error('Error:', err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});