@dedesfr/prompter 0.7.8 → 0.8.0

package/skills/laravel-code-review/references/php84-features.md

@@ -0,0 +1,442 @@
+# PHP 8.4 Features Reference
+
+Quick reference for PHP 8.4 features to use and deprecations to avoid.
+
+---
+
+## New Features to Adopt
+
+### Property Hooks (PHP 8.4)
+
+```php
+// ✅ New: Property hooks
+class User
+{
+    public string $fullName {
+        get => $this->firstName . ' ' . $this->lastName;
+        set => [$this->firstName, $this->lastName] = explode(' ', $value, 2);
+    }
+    
+    public string $email {
+        set => strtolower($value);
+    }
+}
+```
+
+### Asymmetric Visibility (PHP 8.4)
+
+```php
+// ✅ New: Different visibility for get/set
+class User
+{
+    public private(set) string $id;
+    public protected(set) string $name;
+}
+
+// Can read $user->id publicly
+// Can only set $user->id privately
+```
+
+### new Without Parentheses (PHP 8.4)
+
+```php
+// ❌ Old: Required parentheses
+$user = (new User())->setName('John');
+
+// ✅ New: No parentheses needed
+$user = new User()->setName('John');
+```
+
+### Array Find Functions (PHP 8.4)
+
+```php
+// ✅ New: array_find()
+$users = [
+    ['name' => 'John', 'active' => false],
+    ['name' => 'Jane', 'active' => true],
+];
+
+$activeUser = array_find($users, fn($u) => $u['active']);
+// Returns: ['name' => 'Jane', 'active' => true]
+
+// ✅ New: array_find_key()
+$key = array_find_key($users, fn($u) => $u['active']);
+// Returns: 1
+
+// ✅ New: array_any()
+$hasActive = array_any($users, fn($u) => $u['active']);
+// Returns: true
+
+// ✅ New: array_all()
+$allActive = array_all($users, fn($u) => $u['active']);
+// Returns: false
+```
+
+### HTML5 DOM Support (PHP 8.4)
+
+```php
+// ✅ New: Native HTML5 parsing
+$dom = Dom\HTMLDocument::createFromString($html);
+$dom = Dom\HTMLDocument::createFromFile('page.html');
+```
+
+---
+
+## PHP 8.3 Features (Ensure Usage)
+
+### #[Override] Attribute
+
+```php
+// ✅ Use Override for overridden methods
+class CustomHandler extends BaseHandler
+{
+    #[\Override]
+    public function handle(): void
+    {
+        // Implementation
+    }
+}
+```
+
+### Typed Class Constants
+
+```php
+// ✅ Type constants
+class Status
+{
+    public const string PENDING = 'pending';
+    public const string ACTIVE = 'active';
+    public const int MAX_RETRY = 3;
+}
+```
+
+### json_validate()
+
+```php
+// ❌ Old: Decode to validate
+$valid = json_decode($json) !== null;
+
+// ✅ New: Direct validation
+$valid = json_validate($json);
+```
+
+### Randomizer Additions
+
+```php
+// ✅ New random methods
+$randomizer = new Random\Randomizer();
+$randomizer->getBytesFromString('abc', 10);
+$randomizer->nextFloat();
+$randomizer->getFloat(0.0, 1.0);
+```
+
+---
+
+## PHP 8.2 Features (Ensure Usage)
+
+### Readonly Classes
+
+```php
+// ✅ Entire class readonly
+readonly class UserDTO
+{
+    public function __construct(
+        public string $name,
+        public string $email,
+    ) {}
+}
+```
+
+### Null/False/True Types
+
+```php
+// ✅ Standalone null type
+function alwaysNull(): null
+{
+    return null;
+}
+
+// ✅ Standalone false type
+function failed(): false
+{
+    return false;
+}
+```
+
+### Disjunctive Normal Form Types
+
+```php
+// ✅ Complex union types
+function process((A&B)|null $value): void {}
+```
+
+---
+
+## PHP 8.1 Features (Ensure Usage)
+
+### Enums
+
+```php
+// ✅ Backed enums
+enum OrderStatus: string
+{
+    case Pending = 'pending';
+    case Processing = 'processing';
+    case Completed = 'completed';
+    case Cancelled = 'cancelled';
+    
+    public function label(): string
+    {
+        return match($this) {
+            self::Pending => 'Order Pending',
+            self::Processing => 'In Progress',
+            self::Completed => 'Completed',
+            self::Cancelled => 'Cancelled',
+        };
+    }
+}
+```
+
+### Readonly Properties
+
+```php
+// ✅ Immutable properties
+class User
+{
+    public function __construct(
+        public readonly int $id,
+        public readonly string $email,
+    ) {}
+}
+```
+
+### First-Class Callables
+
+```php
+// ❌ Old: Closure::fromCallable
+$fn = Closure::fromCallable([$this, 'method']);
+
+// ✅ New: First-class callable syntax
+$fn = $this->method(...);
+```
+
+### Intersection Types
+
+```php
+// ✅ Require multiple interfaces
+function process(Countable&Iterator $items): void {}
+```
+
+### Fibers
+
+```php
+// ✅ Fiber for async
+$fiber = new Fiber(function() {
+    $value = Fiber::suspend('paused');
+    return $value;
+});
+
+$result = $fiber->start();
+$final = $fiber->resume('resumed');
+```
+
+---
+
+## PHP 8.0 Features (Ensure Usage)
+
+### Constructor Property Promotion
+
+```php
+// ❌ Old
+class User
+{
+    private string $name;
+    
+    public function __construct(string $name)
+    {
+        $this->name = $name;
+    }
+}
+
+// ✅ New: Property promotion
+class User
+{
+    public function __construct(
+        private readonly string $name,
+    ) {}
+}
+```
+
+### Named Arguments
+
+```php
+// ✅ Named arguments for clarity
+$user = new User(
+    name: 'John',
+    email: 'john@example.com',
+    isAdmin: false,
+);
+```
+
+### Match Expression
+
+```php
+// ❌ Old: Switch
+switch ($status) {
+    case 'pending':
+        $color = 'yellow';
+        break;
+    default:
+        $color = 'gray';
+}
+
+// ✅ New: Match
+$color = match($status) {
+    'pending' => 'yellow',
+    'approved' => 'green',
+    default => 'gray',
+};
+```
+
+### Nullsafe Operator
+
+```php
+// ❌ Old: Null checks
+$country = null;
+if ($user !== null && $user->address !== null) {
+    $country = $user->address->country;
+}
+
+// ✅ New: Nullsafe
+$country = $user?->address?->country;
+```
+
+### Union Types
+
+```php
+// ✅ Union types
+function parse(string|int $value): string|false {}
+```
+
+### Attributes
+
+```php
+// ✅ Native attributes
+#[Route('/users', methods: ['GET'])]
+public function index(): Response {}
+
+#[Deprecated('Use newMethod() instead')]
+public function oldMethod(): void {}
+```
+
+---
+
+## Deprecations to Fix
+
+### PHP 8.4 Deprecations
+
+```php
+// ❌ Deprecated: Implicit nullable
+function foo(string $value = null) {}
+
+// ✅ Fixed: Explicit nullable
+function foo(?string $value = null) {}
+
+// ❌ Deprecated: session_register()
+session_register('var');
+
+// ✅ Fixed: Use $_SESSION
+$_SESSION['var'] = $value;
+```
+
+### PHP 8.2 Deprecations
+
+```php
+// ❌ Deprecated: Dynamic properties
+class User
+{
+    public string $name;
+}
+$user = new User();
+$user->undefined = 'value'; // Deprecated!
+
+// ✅ Fixed: Define property or use #[AllowDynamicProperties]
+#[\AllowDynamicProperties]
+class User
+{
+    public string $name;
+}
+```
+
+### PHP 8.1 Deprecations
+
+```php
+// ❌ Deprecated: ${var} in strings
+$name = 'John';
+echo "Hello ${name}"; // Deprecated!
+
+// ✅ Fixed: Use {$var}
+echo "Hello {$name}";
+
+// ❌ Deprecated: Passing null to non-nullable
+strlen(null); // Deprecated!
+
+// ✅ Fixed: Check for null
+strlen($value ?? '');
+```
+
+---
+
+## Type Safety Improvements
+
+### Strict Return Types
+
+```php
+// ❌ Poor: No return type
+public function getUsers()
+{
+    return User::all();
+}
+
+// ✅ Good: Explicit return type
+public function getUsers(): Collection
+{
+    return User::all();
+}
+
+// ✅ Good: Never return type
+public function fail(): never
+{
+    throw new Exception('Failed');
+}
+
+// ✅ Good: Void return type
+public function log(string $message): void
+{
+    Log::info($message);
+}
+```
+
+### Strict Parameter Types
+
+```php
+// ❌ Poor: No parameter types
+public function process($data, $options)
+
+// ✅ Good: Typed parameters
+public function process(array $data, ProcessOptions $options): Result
+```
+
+---
+
+## Detection Patterns
+
+| Issue              | Detection Pattern                                           |
+| ------------------ | ----------------------------------------------------------- |
+| Missing readonly   | Class properties without `readonly` that are never modified |
+| Missing match      | Switch statements that return values                        |
+| Missing nullsafe   | Nested null checks with `&&`                                |
+| Missing named args | Constructor calls with 4+ positional parameters             |
+| Implicit nullable  | Parameters with `= null` but no `?` type                    |
+| Dynamic properties | Property access on undefined properties                     |
+| Old string syntax  | `${var}` instead of `{$var}`                                |

package/src/cli/index.ts

@@ -18,13 +18,14 @@ const program = new Command();
 program
     .name('prompter')
     .description('Enhance prompts directly in your AI coding workflow')
-    .version('0.7.8');
+    .version('0.8.0');
 
 program
     .command('init')
     .description('Initialize Prompter in your project')
     .option('--tools <tools...>', 'Specify AI tools to configure (antigravity, claude, codex, github-copilot, opencode, kilocode)')
     .option('--prompts <prompts...>', 'Specify prompts to install (ai-humanizer, api-contract-generator, apply, archive, design-system, document-explainer, epic-single, epic-generator, erd-generator, fsd-generator, prd-agent-generator, prd-generator, product-brief, proposal, qa-test-scenario, skill-creator, story-single, story-generator, tdd-generator, tdd-lite-generator, wireframe-generator)')
+    .option('--skills <skills...>', 'Specify skills to install by name (e.g. laravel-code-review design-system-generator)')
     .option('--no-interactive', 'Run without interactive prompts')
     .action(async (options) => {
         const initCommand = new InitCommand();

package/src/commands/init.ts

@@ -7,10 +7,12 @@ import { projectTemplate, agentsTemplate, claudeTemplate } from '../core/templat
 import { PROMPT_TEMPLATES } from '../core/prompt-templates.js';
 import { registry } from '../core/configurators/slash/index.js';
 import { SlashCommandId } from '../core/templates/index.js';
+import { discoverSkills, SkillMetadata } from '../core/skill-discovery.js';
 
 interface InitOptions {
     tools?: string[];
     prompts?: string[];
+    skills?: string[];
     noInteractive?: boolean;
 }
 
@@ -145,7 +147,7 @@ export class InitCommand {
                 // Detect currently installed prompts (use path.join to get prompter path)
                 const prompterPathForDetection = path.join(projectPath, PROMPTER_DIR);
                 const currentPrompts = await this.detectInstalledPrompts(prompterPathForDetection);
-                
+
                 selectedPrompts = await checkbox({
                     message: 'Select prompt templates to install:',
                     choices: this.getCategorizedPromptChoices(currentPrompts),
@@ -158,6 +160,34 @@ export class InitCommand {
             }
         }
 
+        // Select skills
+        const availableSkills = await discoverSkills(path.join(projectPath, 'skills'));
+        let selectedSkills: SkillMetadata[] = [];
+
+        if (options.skills && options.skills.length > 0) {
+            const requestedNames = options.skills.flatMap(s => s.split(',').map(s => s.trim()));
+            selectedSkills = availableSkills.filter(s => requestedNames.includes(s.name));
+        } else if (!options.noInteractive && availableSkills.length > 0) {
+            try {
+                const prompterPathForDetection = path.join(projectPath, PROMPTER_DIR);
+                const currentSkillNames = await this.detectInstalledSkills(prompterPathForDetection);
+
+                const selectedSkillNames = await checkbox({
+                    message: 'Select skills to install:',
+                    choices: availableSkills.map(skill => ({
+                        name: `  ${skill.name}`,
+                        value: skill.name,
+                        checked: currentSkillNames.includes(skill.name)
+                    }))
+                });
+                selectedSkills = availableSkills.filter(s => selectedSkillNames.includes(s.name));
+            } catch (error) {
+                // User cancelled
+                console.log(chalk.yellow(isReInitialization ? '\nRe-configuration cancelled.' : '\nInitialization cancelled.'));
+                return;
+            }
+        }
+
         // Create or ensure prompter directory
         const prompterPath = await PrompterConfig.ensurePrompterDir(projectPath);
         if (!isReInitialization) {
@@ -349,10 +379,13 @@ export class InitCommand {
             }
         }
 
+        // --- Skills setup ---
+        const skillChanges = await this.setupSkills(projectPath, prompterPath, selectedTools, selectedSkills);
+
         // Success message
         if (isReInitialization) {
             console.log(chalk.green('\n✅ Prompter tools updated successfully!\n'));
-            if (toolsToAdd.length > 0 || toolsToRemove.length > 0 || promptsToAdd.length > 0 || promptsToRemove.length > 0) {
+            if (toolsToAdd.length > 0 || toolsToRemove.length > 0 || promptsToAdd.length > 0 || promptsToRemove.length > 0 || skillChanges.added.length > 0 || skillChanges.removed.length > 0) {
                 console.log(chalk.blue('Summary:'));
                 if (toolsToAdd.length > 0) {
                     console.log(chalk.green('  Tools Added: ') + toolsToAdd.map(t => {
@@ -378,6 +411,12 @@ export class InitCommand {
                         return prompt ? prompt.name : p;
                     }).join(', '));
                 }
+                if (skillChanges.added.length > 0) {
+                    console.log(chalk.green('  Skills Added: ') + skillChanges.added.join(', '));
+                }
+                if (skillChanges.removed.length > 0) {
+                    console.log(chalk.yellow('  Skills Removed: ') + skillChanges.removed.join(', '));
+                }
                 console.log();
             } else {
                 console.log(chalk.gray('  No changes made.\n'));
@@ -387,6 +426,9 @@ export class InitCommand {
             if (promptsToAdd.length > 0) {
                 console.log(chalk.gray(`Installed ${promptsToAdd.length} prompt template(s).\n`));
             }
+            if (skillChanges.added.length > 0) {
+                console.log(chalk.gray(`Installed ${skillChanges.added.length} skill(s).\n`));
+            }
             console.log(chalk.gray('Run `prompter guide` for next steps.\n'));
         }
     }
@@ -604,6 +646,144 @@ Use \`@/prompter/CLAUDE.md\` to learn:
         }
     }
 
+    private async setupSkills(
+        projectPath: string,
+        prompterPath: string,
+        selectedTools: string[],
+        selectedSkills: SkillMetadata[]
+    ): Promise<{ added: string[]; removed: string[] }> {
+        const result = { added: [] as string[], removed: [] as string[] };
+
+        const installedSkillNames = await this.detectInstalledSkills(prompterPath);
+        const selectedSkillNames = selectedSkills.map(s => s.name);
+
+        const skillsToAdd = selectedSkills.filter(s => !installedSkillNames.includes(s.name));
+        const skillsToRemove = installedSkillNames.filter(n => !selectedSkillNames.includes(n));
+        const skillsToKeep = selectedSkills.filter(s => installedSkillNames.includes(s.name));
+
+        const skillsTargetDir = path.join(prompterPath, 'skills');
+
+        // Remove deselected skills
+        if (skillsToRemove.length > 0) {
+            console.log(chalk.blue('\n🗑️  Removing skills...\n'));
+
+            for (const skillName of skillsToRemove) {
+                const staleDir = path.join(skillsTargetDir, skillName);
+                try {
+                    await fs.rm(staleDir, { recursive: true, force: true });
+                    console.log(chalk.yellow('✓') + ` Removed skill ${chalk.cyan(skillName)}`);
+                    result.removed.push(skillName);
+                } catch {
+                    // ignore
+                }
+
+                for (const toolId of selectedTools) {
+                    const configurator = registry.get(toolId);
+                    if (!configurator) continue;
+                    const removed = await configurator.removeSkillFiles(projectPath, [skillName]);
+                    for (const file of removed) {
+                        console.log(chalk.yellow('✓') + ` Removed ${chalk.cyan(file)}`);
+                    }
+                }
+            }
+        }
+
+        // Install new skills
+        if (skillsToAdd.length > 0) {
+            console.log(chalk.blue('\n🧩 Installing skills...\n'));
+            await fs.mkdir(skillsTargetDir, { recursive: true });
+
+            for (const skill of skillsToAdd) {
+                const targetDir = path.join(skillsTargetDir, skill.name);
+                try {
+                    await this.copyDirectory(skill.sourcePath, targetDir);
+                    console.log(chalk.green('✓') + ` Installed skill ${chalk.cyan(skill.name)}`);
+                    result.added.push(skill.name);
+                } catch (error) {
+                    console.log(chalk.red('✗') + ` Failed to install skill ${skill.name}: ${error}`);
+                }
+            }
+
+            if (selectedTools.length > 0) {
+                console.log(chalk.blue('\n📝 Creating skill workflow files...\n'));
+                for (const toolId of selectedTools) {
+                    const configurator = registry.get(toolId);
+                    if (!configurator) continue;
+                    try {
+                        const files = await configurator.generateSkills(projectPath, skillsToAdd);
+                        for (const file of files) {
+                            console.log(chalk.green('✓') + ` Created ${chalk.cyan(file)}`);
+                        }
+                    } catch (error) {
+                        console.log(chalk.red('✗') + ` Failed to create skill files for ${toolId}: ${error}`);
+                    }
+                }
+            }
+        }
+
+        // Update kept skills
+        if (skillsToKeep.length > 0) {
+            await fs.mkdir(skillsTargetDir, { recursive: true });
+
+            for (const skill of skillsToKeep) {
+                const targetDir = path.join(skillsTargetDir, skill.name);
+                try {
+                    await this.copyDirectory(skill.sourcePath, targetDir);
+                } catch {
+                    // ignore update errors
+                }
+            }
+
+            for (const toolId of selectedTools) {
+                const configurator = registry.get(toolId);
+                if (!configurator) continue;
+                try {
+                    await configurator.generateSkills(projectPath, skillsToKeep);
+                } catch {
+                    // ignore
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private async detectInstalledSkills(prompterPath: string): Promise<string[]> {
+        const skillsDir = path.join(prompterPath, 'skills');
+        const names: string[] = [];
+
+        try {
+            const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md');
+                if (await this.fileExists(skillMdPath)) {
+                    names.push(entry.name);
+                }
+            }
+        } catch {
+            // skills directory doesn't exist yet
+        }
+
+        return names;
+    }
+
+    private async copyDirectory(src: string, dest: string): Promise<void> {
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+
+            if (entry.isDirectory()) {
+                await this.copyDirectory(srcPath, destPath);
+            } else {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+    }
+
     private async ensureRootAgentsFile(projectPath: string): Promise<void> {
         const rootAgentsPath = path.join(projectPath, 'AGENTS.md');
         const instructionsBlock = `<!-- PROMPTER:START -->