@dedesfr/prompter 0.8.23 → 1.0.0

package/src/core/config-schema.ts

@@ -1,230 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Zod schema for global Prompter configuration.
- * Uses passthrough() to preserve unknown fields for forward compatibility.
- */
-export const GlobalConfigSchema = z
-  .object({
-    featureFlags: z
-      .record(z.string(), z.boolean())
-      .optional()
-      .default({}),
-  })
-  .passthrough();
-
-export type GlobalConfigType = z.infer<typeof GlobalConfigSchema>;
-
-/**
- * Default configuration values.
- */
-export const DEFAULT_CONFIG: GlobalConfigType = {
-  featureFlags: {},
-};
-
-const KNOWN_TOP_LEVEL_KEYS = new Set(Object.keys(DEFAULT_CONFIG));
-
-/**
- * Validate a config key path for CLI set operations.
- * Unknown top-level keys are rejected unless explicitly allowed by the caller.
- */
-export function validateConfigKeyPath(path: string): { valid: boolean; reason?: string } {
-  const rawKeys = path.split('.');
-
-  if (rawKeys.length === 0 || rawKeys.some((key) => key.trim() === '')) {
-    return { valid: false, reason: 'Key path must not be empty' };
-  }
-
-  const rootKey = rawKeys[0];
-  if (!KNOWN_TOP_LEVEL_KEYS.has(rootKey)) {
-    return { valid: false, reason: `Unknown top-level key "${rootKey}"` };
-  }
-
-  if (rootKey === 'featureFlags') {
-    if (rawKeys.length > 2) {
-      return { valid: false, reason: 'featureFlags values are booleans and do not support nested keys' };
-    }
-    return { valid: true };
-  }
-
-  if (rawKeys.length > 1) {
-    return { valid: false, reason: `"${rootKey}" does not support nested keys` };
-  }
-
-  return { valid: true };
-}
-
-/**
- * Get a nested value from an object using dot notation.
- *
- * @param obj - The object to access
- * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
- * @returns The value at the path, or undefined if not found
- */
-export function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
-  const keys = path.split('.');
-  let current: unknown = obj;
-
-  for (const key of keys) {
-    if (current === null || current === undefined) {
-      return undefined;
-    }
-    if (typeof current !== 'object') {
-      return undefined;
-    }
-    current = (current as Record<string, unknown>)[key];
-  }
-
-  return current;
-}
-
-/**
- * Set a nested value in an object using dot notation.
- * Creates intermediate objects as needed.
- *
- * @param obj - The object to modify (mutated in place)
- * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
- * @param value - The value to set
- */
-export function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void {
-  const keys = path.split('.');
-  let current: Record<string, unknown> = obj;
-
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (current[key] === undefined || current[key] === null || typeof current[key] !== 'object') {
-      current[key] = {};
-    }
-    current = current[key] as Record<string, unknown>;
-  }
-
-  const lastKey = keys[keys.length - 1];
-  current[lastKey] = value;
-}
-
-/**
- * Delete a nested value from an object using dot notation.
- *
- * @param obj - The object to modify (mutated in place)
- * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
- * @returns true if the key existed and was deleted, false otherwise
- */
-export function deleteNestedValue(obj: Record<string, unknown>, path: string): boolean {
-  const keys = path.split('.');
-  let current: Record<string, unknown> = obj;
-
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (current[key] === undefined || current[key] === null || typeof current[key] !== 'object') {
-      return false;
-    }
-    current = current[key] as Record<string, unknown>;
-  }
-
-  const lastKey = keys[keys.length - 1];
-  if (lastKey in current) {
-    delete current[lastKey];
-    return true;
-  }
-  return false;
-}
-
-/**
- * Coerce a string value to its appropriate type.
- * - "true" / "false" -> boolean
- * - Numeric strings -> number
- * - Everything else -> string
- *
- * @param value - The string value to coerce
- * @param forceString - If true, always return the value as a string
- * @returns The coerced value
- */
-export function coerceValue(value: string, forceString: boolean = false): string | number | boolean {
-  if (forceString) {
-    return value;
-  }
-
-  // Boolean coercion
-  if (value === 'true') {
-    return true;
-  }
-  if (value === 'false') {
-    return false;
-  }
-
-  // Number coercion - must be a valid finite number
-  const num = Number(value);
-  if (!isNaN(num) && isFinite(num) && value.trim() !== '') {
-    return num;
-  }
-
-  return value;
-}
-
-/**
- * Format a value for YAML-like display.
- *
- * @param value - The value to format
- * @param indent - Current indentation level
- * @returns Formatted string
- */
-export function formatValueYaml(value: unknown, indent: number = 0): string {
-  const indentStr = '  '.repeat(indent);
-
-  if (value === null || value === undefined) {
-    return 'null';
-  }
-
-  if (typeof value === 'boolean' || typeof value === 'number') {
-    return String(value);
-  }
-
-  if (typeof value === 'string') {
-    return value;
-  }
-
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return '[]';
-    }
-    return value.map((item) => `${indentStr}- ${formatValueYaml(item, indent + 1)}`).join('\n');
-  }
-
-  if (typeof value === 'object') {
-    const entries = Object.entries(value as Record<string, unknown>);
-    if (entries.length === 0) {
-      return '{}';
-    }
-    return entries
-      .map(([key, val]) => {
-        const formattedVal = formatValueYaml(val, indent + 1);
-        if (typeof val === 'object' && val !== null && Object.keys(val).length > 0) {
-          return `${indentStr}${key}:\n${formattedVal}`;
-        }
-        return `${indentStr}${key}: ${formattedVal}`;
-      })
-      .join('\n');
-  }
-
-  return String(value);
-}
-
-/**
- * Validate a configuration object against the schema.
- *
- * @param config - The configuration to validate
- * @returns Validation result with success status and optional error message
- */
-export function validateConfig(config: unknown): { success: boolean; error?: string } {
-  try {
-    GlobalConfigSchema.parse(config);
-    return { success: true };
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const zodError = error as z.ZodError;
-      const messages = zodError.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
-      return { success: false, error: messages.join('; ') };
-    }
-    return { success: false, error: 'Unknown validation error' };
-  }
-}

package/src/core/config.ts

@@ -1,181 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-export const PROMPTER_DIR = 'prompter';
-
-export const PROMPTER_MARKERS = {
-    start: '<!-- prompter-managed-start -->',
-    end: '<!-- prompter-managed-end -->'
-};
-
-export interface ToolChoice {
-    name: string;
-    value: string;
-    available: boolean;
-    successLabel: string;
-}
-
-export interface PromptChoice {
-    name: string;
-    value: string;
-    description: string;
-    sourceFile: string;
-}
-
-export const SUPPORTED_TOOLS: ToolChoice[] = [
-    { name: 'Antigravity', value: 'antigravity', available: true, successLabel: 'Antigravity' },
-    { name: 'Claude Code', value: 'claude', available: true, successLabel: 'Claude Code' },
-    { name: 'Codex', value: 'codex', available: true, successLabel: 'Codex' },
-    { name: 'GitHub Copilot', value: 'github-copilot', available: true, successLabel: 'GitHub Copilot' },
-    { name: 'OpenCode', value: 'opencode', available: true, successLabel: 'OpenCode' },
-    { name: 'Kilo Code', value: 'kilocode', available: true, successLabel: 'Kilo Code' },
-    { name: 'Forge', value: 'forge', available: true, successLabel: 'Forge' },
-    { name: 'Droid', value: 'droid', available: true, successLabel: 'Droid' }
-];
-
-export const AVAILABLE_PROMPTS: PromptChoice[] = [
-    {
-        name: 'AI Humanizer',
-        value: 'ai-humanizer',
-        description: 'Transform AI-generated text into natural, human-like content',
-        sourceFile: 'ai-humanizer.md'
-    },
-    {
-        name: 'API Contract Generator',
-        value: 'api-contract-generator',
-        description: 'Generate OpenAPI specification from FSD and ERD',
-        sourceFile: 'api-contract-generator.md'
-    },
-    {
-        name: 'Apply',
-        value: 'apply',
-        description: 'Implement and apply an approved change proposal',
-        sourceFile: 'apply.md'
-    },
-    {
-        name: 'Archive',
-        value: 'archive',
-        description: 'Archive a completed change and update specs',
-        sourceFile: 'archive.md'
-    },
-    {
-        name: 'Design System',
-        value: 'design-system',
-        description: 'Generate comprehensive design system documentation for components and tokens',
-        sourceFile: 'design-system.md'
-    },
-    {
-        name: 'Document Explainer',
-        value: 'document-explainer',
-        description: 'Analyze and explain complex documents into clear, actionable insights',
-        sourceFile: 'document-explainer.md'
-    },
-    {
-        name: 'Epic (Single)',
-        value: 'epic-single',
-        description: 'Generate comprehensive epic documentation',
-        sourceFile: 'epic-single.md'
-    },
-    {
-        name: 'Epic Generator',
-        value: 'epic-generator',
-        description: 'Generate comprehensive EPICs from FSD and TDD documentation',
-        sourceFile: 'epic-generator.md'
-    },
-    {
-        name: 'ERD Generator',
-        value: 'erd-generator',
-        description: 'Generate Entity Relationship Diagram from FSD',
-        sourceFile: 'erd-generator.md'
-    },
-    {
-        name: 'FSD Generator',
-        value: 'fsd-generator',
-        description: 'Generate Functional Specification Document from PRD',
-        sourceFile: 'fsd-generator.md'
-    },
-    {
-        name: 'PRD Agent Generator',
-        value: 'prd-agent-generator',
-        description: 'Create AGENT.md files with Product Requirements Document prompts',
-        sourceFile: 'prd-agent-generator.md'
-    },
-    {
-        name: 'PRD Generator',
-        value: 'prd-generator',
-        description: 'Generate detailed Product Requirements Documents',
-        sourceFile: 'prd-generator.md'
-    },
-    {
-        name: 'Product Brief',
-        value: 'product-brief',
-        description: 'Create concise product brief documents',
-        sourceFile: 'product-brief.md'
-    },
-    {
-        name: 'Proposal',
-        value: 'proposal',
-        description: 'Create a new change proposal with spec deltas',
-        sourceFile: 'proposal.md'
-    },
-    {
-        name: 'QA Test Scenario',
-        value: 'qa-test-scenario',
-        description: 'Generate comprehensive test scenarios and test cases',
-        sourceFile: 'qa-test-scenario.md'
-    },
-    {
-        name: 'Skill Creator',
-        value: 'skill-creator',
-        description: 'Create structured skill documentation for AI agents',
-        sourceFile: 'skill-creator.md'
-    },
-    {
-        name: 'Story (Single)',
-        value: 'story-single',
-        description: 'Generate detailed user story documentation',
-        sourceFile: 'story-single.md'
-    },
-    {
-        name: 'Story Generator',
-        value: 'story-generator',
-        description: 'Generate comprehensive user stories from EPICs and FSD',
-        sourceFile: 'story-generator.md'
-    },
-    {
-        name: 'TDD Generator',
-        value: 'tdd-generator',
-        description: 'Generate comprehensive Technical Design Document',
-        sourceFile: 'tdd-generator.md'
-    },
-    {
-        name: 'TDD-Lite Generator',
-        value: 'tdd-lite-generator',
-        description: 'Generate lean Technical Design Document (TDD-Lite)',
-        sourceFile: 'tdd-lite-generator.md'
-    },
-    {
-        name: 'Wireframe Generator',
-        value: 'wireframe-generator',
-        description: 'Generate UI/UX wireframes from technical specs',
-        sourceFile: 'wireframe-generator.md'
-    }
-];
-
-export class PrompterConfig {
-    static async ensurePrompterDir(projectPath: string): Promise<string> {
-        const prompterPath = path.join(projectPath, PROMPTER_DIR);
-        await fs.mkdir(prompterPath, { recursive: true });
-        return prompterPath;
-    }
-
-    static async prompterDirExists(projectPath: string): Promise<boolean> {
-        try {
-            const prompterPath = path.join(projectPath, PROMPTER_DIR);
-            await fs.access(prompterPath);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-}

package/src/core/configurators/slash/antigravity.ts

@@ -1,70 +0,0 @@
-import { SlashCommandConfigurator } from './base.js';
-import { SlashCommandId } from '../../templates/index.js';
-
-const FILE_PATHS: Record<SlashCommandId, string> = {
-    enhance: '.agent/workflows/prompter-enhance.md',
-    'prd-generator': '.agent/workflows/prd-generator.md',
-    'prd-agent-generator': '.agent/workflows/prd-agent-generator.md',
-    'product-brief': '.agent/workflows/product-brief.md',
-    'epic-single': '.agent/workflows/epic-single.md',
-    'epic-generator': '.agent/workflows/epic-generator.md',
-    'story-single': '.agent/workflows/story-single.md',
-    'story-generator': '.agent/workflows/story-generator.md',
-    'qa-test-scenario': '.agent/workflows/qa-test-scenario.md',
-    'skill-creator': '.agent/workflows/skill-creator.md',
-    'ai-humanizer': '.agent/workflows/ai-humanizer.md',
-    'api-contract-generator': '.agent/workflows/api-contract-generator.md',
-    'apply': '.agent/workflows/apply.md',
-    'archive': '.agent/workflows/archive.md',
-    'design-system': '.agent/workflows/design-system.md',
-    'erd-generator': '.agent/workflows/erd-generator.md',
-    'fsd-generator': '.agent/workflows/fsd-generator.md',
-    'proposal': '.agent/workflows/proposal.md',
-    'tdd-generator': '.agent/workflows/tdd-generator.md',
-    'tdd-lite-generator': '.agent/workflows/tdd-lite-generator.md',
-    'wireframe-generator': '.agent/workflows/wireframe-generator.md',
-    'document-explainer': '.agent/workflows/document-explainer.md'
-};
-
-const DESCRIPTIONS: Record<SlashCommandId, string> = {
-    enhance: 'Enhance a rough prompt into a professional specification',
-    'prd-generator': 'Generate a comprehensive Product Requirements Document (PRD)',
-    'prd-agent-generator': 'Generate a PRD with autonomous assumptions (non-interactive mode)',
-    'product-brief': 'Generate an executive-level product brief (1-page summary)',
-    'epic-single': 'Generate a single well-defined Jira Epic',
-    'epic-generator': 'Generate a comprehensive set of EPICs from documentation',
-    'story-single': 'Generate a single Jira User Story from requirements',
-    'story-generator': 'Generate comprehensive user stories from EPICs and FSD',
-    'qa-test-scenario': 'Generate focused QA test scenarios from PRD',
-    'skill-creator': 'Create a modular skill package that extends AI agent capabilities',
-    'ai-humanizer': 'Humanize and proofread AI-generated content for natural, publication-ready output',
-    'api-contract-generator': 'Generate OpenAPI specification from FSD and ERD',
-    'apply': 'Implement and apply an approved change proposal',
-    'archive': 'Archive a completed change and update specs',
-    'design-system': 'Generate comprehensive design system documentation for components and tokens',
-    'erd-generator': 'Generate Entity Relationship Diagram from FSD',
-    'fsd-generator': 'Generate Functional Specification Document from PRD',
-    'proposal': 'Create a new change proposal with spec deltas',
-    'tdd-generator': 'Generate comprehensive Technical Design Document',
-    'tdd-lite-generator': 'Generate lean Technical Design Document (TDD-Lite)',
-    'wireframe-generator': 'Generate UI/UX wireframes from technical specs',
-    'document-explainer': 'Analyze and explain complex documents into clear, actionable insights'
-};
-
-export class AntigravityConfigurator extends SlashCommandConfigurator {
-    readonly toolId = 'antigravity';
-    readonly isAvailable = true;
-
-    protected getRelativePath(id: SlashCommandId): string {
-        return FILE_PATHS[id];
-    }
-
-    protected getFrontmatter(id: SlashCommandId): string | undefined {
-        const description = DESCRIPTIONS[id];
-        return `---\ndescription: ${description}\n---`;
-    }
-
-    protected getSkillTargetDir(skillName: string): string {
-        return `.agent/skills/${skillName}`;
-    }
-}

package/src/core/configurators/slash/base.ts

@@ -1,203 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import { SlashCommandId, TemplateManager } from '../../templates/index.js';
-import { PROMPTER_MARKERS } from '../../config.js';
-import { SkillMetadata } from '../../skill-discovery.js';
-
-export interface SlashCommandTarget {
-    id: SlashCommandId;
-    path: string;
-    kind: 'slash';
-}
-
-export interface SkillTarget {
-    name: string;
-    path: string;
-    kind: 'skill';
-}
-
-const ALL_COMMANDS: SlashCommandId[] = ['enhance', 'prd-generator', 'prd-agent-generator', 'product-brief', 'epic-single', 'epic-generator', 'story-single', 'story-generator', 'qa-test-scenario', 'skill-creator', 'ai-humanizer', 'api-contract-generator', 'apply', 'archive', 'design-system', 'erd-generator', 'fsd-generator', 'proposal', 'tdd-generator', 'tdd-lite-generator', 'wireframe-generator', 'document-explainer'];
-
-export abstract class SlashCommandConfigurator {
-    abstract readonly toolId: string;
-    abstract readonly isAvailable: boolean;
-
-    getTargets(filterIds?: SlashCommandId[]): SlashCommandTarget[] {
-        // If filterIds is undefined, generate all commands
-        // If filterIds is an empty array, generate nothing
-        // If filterIds has items, generate only those
-        const commandsToGenerate = filterIds === undefined
-            ? ALL_COMMANDS
-            : ALL_COMMANDS.filter(id => filterIds.includes(id));
-
-        return commandsToGenerate.map((id) => ({
-            id,
-            path: this.getRelativePath(id),
-            kind: 'slash'
-        }));
-    }
-
-    async generateAll(projectPath: string, filterIds?: SlashCommandId[]): Promise<string[]> {
-        const createdOrUpdated: string[] = [];
-
-        for (const target of this.getTargets(filterIds)) {
-            const body = this.getBody(target.id);
-            const filePath = path.join(projectPath, target.path);
-
-            // Ensure directory exists
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-
-            if (await this.fileExists(filePath)) {
-                await this.updateBody(filePath, body);
-            } else {
-                const frontmatter = this.getFrontmatter(target.id);
-                const sections: string[] = [];
-                if (frontmatter) {
-                    sections.push(frontmatter.trim());
-                }
-                sections.push(`${PROMPTER_MARKERS.start}\n${body}\n${PROMPTER_MARKERS.end}`);
-                const content = sections.join('\n') + '\n';
-                await fs.writeFile(filePath, content, 'utf-8');
-            }
-
-            createdOrUpdated.push(target.path);
-        }
-
-        return createdOrUpdated;
-    }
-
-    async updateExisting(projectPath: string): Promise<string[]> {
-        const updated: string[] = [];
-
-        for (const target of this.getTargets()) {
-            const filePath = path.join(projectPath, target.path);
-            if (await this.fileExists(filePath)) {
-                const body = this.getBody(target.id);
-                await this.updateBody(filePath, body);
-                updated.push(target.path);
-            }
-        }
-
-        return updated;
-    }
-
-    protected abstract getRelativePath(id: SlashCommandId): string;
-    protected abstract getFrontmatter(id: SlashCommandId): string | undefined;
-
-    /**
-     * Returns the relative directory path where the skill's full directory
-     * will be placed inside the tool's config dir.
-     * e.g. `.claude/skills/laravel-code-review`
-     */
-    protected abstract getSkillTargetDir(skillName: string): string;
-
-    protected getBody(id: SlashCommandId): string {
-        return TemplateManager.getSlashCommandBody(id).trim();
-    }
-
-    // --- Skill directory management ---
-
-    getSkillTargets(skills: SkillMetadata[]): SkillTarget[] {
-        return skills.map(skill => ({
-            name: skill.name,
-            path: this.getSkillTargetDir(skill.name),
-            kind: 'skill'
-        }));
-    }
-
-    async generateSkills(projectPath: string, skills: SkillMetadata[]): Promise<string[]> {
-        const created: string[] = [];
-
-        for (const skill of skills) {
-            const targetDir = path.join(projectPath, this.getSkillTargetDir(skill.name));
-            await this.copyDir(skill.sourcePath, targetDir);
-            created.push(this.getSkillTargetDir(skill.name));
-        }
-
-        return created;
-    }
-
-    async updateExistingSkills(projectPath: string, skills: SkillMetadata[]): Promise<string[]> {
-        const updated: string[] = [];
-
-        for (const skill of skills) {
-            const relativeDir = this.getSkillTargetDir(skill.name);
-            const targetDir = path.join(projectPath, relativeDir);
-
-            if (await this.dirExists(targetDir)) {
-                await this.copyDir(skill.sourcePath, targetDir);
-                updated.push(relativeDir);
-            }
-        }
-
-        return updated;
-    }
-
-    async removeSkillFiles(projectPath: string, skillNames: string[]): Promise<string[]> {
-        const removed: string[] = [];
-
-        for (const name of skillNames) {
-            const relativeDir = this.getSkillTargetDir(name);
-            const targetDir = path.join(projectPath, relativeDir);
-
-            if (await this.dirExists(targetDir)) {
-                await fs.rm(targetDir, { recursive: true, force: true });
-                removed.push(relativeDir);
-            }
-        }
-
-        return removed;
-    }
-
-    private async copyDir(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.copyDir(srcPath, destPath);
-            } else {
-                await fs.copyFile(srcPath, destPath);
-            }
-        }
-    }
-
-    private async dirExists(dirPath: string): Promise<boolean> {
-        try {
-            const stat = await fs.stat(dirPath);
-            return stat.isDirectory();
-        } catch {
-            return false;
-        }
-    }
-
-    // --- Shared helpers ---
-
-    protected async updateBody(filePath: string, body: string): Promise<void> {
-        const content = await fs.readFile(filePath, 'utf-8');
-        const startIndex = content.indexOf(PROMPTER_MARKERS.start);
-        const endIndex = content.indexOf(PROMPTER_MARKERS.end);
-
-        if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
-            throw new Error(`Missing Prompter markers in ${filePath}`);
-        }
-
-        const before = content.slice(0, startIndex + PROMPTER_MARKERS.start.length);
-        const after = content.slice(endIndex);
-        const updatedContent = `${before}\n${body}\n${after}`;
-
-        await fs.writeFile(filePath, updatedContent, 'utf-8');
-    }
-
-    private async fileExists(filePath: string): Promise<boolean> {
-        try {
-            await fs.access(filePath);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-}