@thiagodiogo/pscode 1.0.0 → 2.0.0

package/dist/core/migration.js

@@ -1,19 +1,20 @@
 /**
  * Migration Utilities
  *
- * One-time migration logic for existing projects when profile system is introduced.
- * Called by both init and update commands before profile resolution.
+ * Scans installed workflow artifacts across tools.
+ * Called by init and update commands.
  */
-import { getGlobalConfig, getGlobalConfigPath, saveGlobalConfig } from './global-config.js';
 import { CommandAdapterRegistry } from './command-generation/index.js';
 import { WORKFLOW_TO_SKILL_DIR } from './profile-sync-drift.js';
 import { ALL_WORKFLOWS } from './profiles.js';
 import path from 'path';
 import * as fs from 'fs';
-function scanInstalledWorkflowArtifacts(projectPath, tools) {
+/**
+ * Scans installed workflow files across all detected tools and returns
+ * the union of installed workflow IDs.
+ */
+export function scanInstalledWorkflows(projectPath, tools) {
     const installed = new Set();
-    let hasSkills = false;
-    let hasCommands = false;
     for (const tool of tools) {
         if (!tool.skillsDir)
             continue;
@@ -23,7 +24,6 @@ function scanInstalledWorkflowArtifacts(projectPath, tools) {
             const skillFile = path.join(skillsDir, skillDirName, 'SKILL.md');
             if (fs.existsSync(skillFile)) {
                 installed.add(workflowId);
-                hasSkills = true;
             }
         }
         const adapter = CommandAdapterRegistry.get(tool.value);
@@ -36,73 +36,11 @@ function scanInstalledWorkflowArtifacts(projectPath, tools) {
                 : path.join(projectPath, commandPath);
             if (fs.existsSync(fullPath)) {
                 installed.add(workflowId);
-                hasCommands = true;
             }
         }
     }
-    return {
-        workflows: ALL_WORKFLOWS.filter((workflowId) => installed.has(workflowId)),
-        hasSkills,
-        hasCommands,
-    };
-}
-/**
- * Scans installed workflow files across all detected tools and returns
- * the union of installed workflow IDs.
- */
-export function scanInstalledWorkflows(projectPath, tools) {
-    return scanInstalledWorkflowArtifacts(projectPath, tools).workflows;
-}
-function inferDelivery(artifacts) {
-    if (artifacts.hasSkills && artifacts.hasCommands) {
-        return 'both';
-    }
-    if (artifacts.hasCommands) {
-        return 'commands';
-    }
-    return 'skills';
-}
-/**
- * Performs one-time migration if the global config does not yet have a profile field.
- * Called by both init and update before profile resolution.
- *
- * - If no profile field exists and workflows are installed: sets profile to 'custom'
- *   with the detected workflows, preserving the user's existing setup.
- * - If no profile field exists and no workflows are installed: no-op (defaults apply).
- * - If profile field already exists: no-op.
- */
-export function migrateIfNeeded(projectPath, tools) {
-    const config = getGlobalConfig();
-    // Check raw config file for profile field presence
-    const configPath = getGlobalConfigPath();
-    let rawConfig = {};
-    try {
-        if (fs.existsSync(configPath)) {
-            rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        }
-    }
-    catch {
-        return; // Can't read config, skip migration
-    }
-    // If profile is already explicitly set, no migration needed
-    if (rawConfig.profile !== undefined) {
-        return;
-    }
-    // Scan for installed workflows
-    const artifacts = scanInstalledWorkflowArtifacts(projectPath, tools);
-    const installedWorkflows = artifacts.workflows;
-    if (installedWorkflows.length === 0) {
-        // No workflows installed, new user — defaults will apply
-        return;
-    }
-    // Migrate: set profile to custom with detected workflows
-    config.profile = 'custom';
-    config.workflows = installedWorkflows;
-    if (rawConfig.delivery === undefined) {
-        config.delivery = inferDelivery(artifacts);
-    }
-    saveGlobalConfig(config);
-    console.log(`Migrated: custom profile with ${installedWorkflows.length} workflows`);
-    console.log("New in this version: /ps:propose. Try 'pscode config profile core' for the streamlined experience.");
+    return ALL_WORKFLOWS.filter((id) => installed.has(id));
 }
+// No-op kept for call-site compatibility during transition.
+export function migrateIfNeeded(_projectPath, _tools) { }
 //# sourceMappingURL=migration.js.map

package/dist/core/presets/dixi.d.ts

@@ -0,0 +1,32 @@
+export type DixiStack = 'java-maven' | 'java-gradle' | 'next' | 'react' | 'node' | 'python';
+export type DixiStackFamily = 'java' | 'react' | 'node' | 'python';
+export declare function detectDixiStack(projectDir: string): DixiStack | null;
+export declare function getDixiStackFamily(stack: DixiStack | null): DixiStackFamily | null;
+export declare function getDixiStackLabel(stack: DixiStack | null): string;
+/**
+ * Copies files recursively from sourceDir to targetDir.
+ * By default skips files that already exist (brownfield-safe).
+ * Files whose basename appears in options.overwrite are always overwritten.
+ */
+export declare function copyKitFiles(sourceDir: string, targetDir: string, options?: {
+    overwrite?: string[];
+}): void;
+/**
+ * Copies all files from srcDir into <destRoot>/pastelsdd/context/, skipping files that already exist.
+ * Creates the destination directory if needed.
+ */
+export declare function copyContextDocs(destRoot: string, srcDir: string): void;
+export declare function installDixiClaudeMd(projectDir: string, family: DixiStackFamily | null): void;
+export declare function detectBasePackage(projectRoot: string): string;
+export declare function applyHexagonalSkeleton(projectRoot: string, basePackage: string): {
+    created: number;
+    skipped: number;
+};
+export declare function generateArchitectureTest(projectRoot: string, basePackage: string): boolean;
+export declare function applyFeatureSlicedSkeleton(projectRoot: string): {
+    created: number;
+    skipped: number;
+};
+export declare function installEslintArchitectureTemplate(projectRoot: string): void;
+export declare function installDixiExtras(projectDir: string, stack: DixiStack | null): void;
+//# sourceMappingURL=dixi.d.ts.map

package/dist/core/presets/dixi.js

@@ -0,0 +1,405 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { parse as parseYaml } from 'yaml';
+export function detectDixiStack(projectDir) {
+    if (fs.existsSync(path.join(projectDir, 'pom.xml')))
+        return 'java-maven';
+    if (fs.existsSync(path.join(projectDir, 'build.gradle')))
+        return 'java-gradle';
+    if (fs.existsSync(path.join(projectDir, 'next.config.js')) ||
+        fs.existsSync(path.join(projectDir, 'next.config.ts')) ||
+        fs.existsSync(path.join(projectDir, 'next.config.mjs')))
+        return 'next';
+    const pkgPath = path.join(projectDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+            if ('next' in deps)
+                return 'next';
+            if ('react' in deps)
+                return 'react';
+        }
+        catch {
+            // fallback to 'node' when package.json has invalid JSON
+        }
+        return 'node';
+    }
+    if (fs.existsSync(path.join(projectDir, 'pyproject.toml')))
+        return 'python';
+    return null;
+}
+export function getDixiStackFamily(stack) {
+    if (stack === null)
+        return null;
+    if (stack === 'java-maven' || stack === 'java-gradle')
+        return 'java';
+    if (stack === 'next')
+        return 'react';
+    return stack;
+}
+export function getDixiStackLabel(stack) {
+    if (stack === null)
+        return 'desconhecida';
+    const labels = {
+        'java-maven': 'Java/Maven',
+        'java-gradle': 'Java/Gradle',
+        'next': 'Next.js',
+        'react': 'React',
+        'node': 'Node.js',
+        'python': 'Python',
+    };
+    return labels[stack];
+}
+/**
+ * Copies files recursively from sourceDir to targetDir.
+ * By default skips files that already exist (brownfield-safe).
+ * Files whose basename appears in options.overwrite are always overwritten.
+ */
+export function copyKitFiles(sourceDir, targetDir, options = {}) {
+    if (!fs.existsSync(sourceDir))
+        return;
+    const overwriteSet = new Set(options.overwrite ?? []);
+    function copyDir(src, dest) {
+        if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest, { recursive: true });
+        }
+        const entries = fs.readdirSync(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()) {
+                copyDir(srcPath, destPath);
+            }
+            else {
+                if (fs.existsSync(destPath) && !overwriteSet.has(entry.name)) {
+                    console.log(`  ${entry.name} já existe — pulado`);
+                    continue;
+                }
+                const destDirPath = path.dirname(destPath);
+                if (!fs.existsSync(destDirPath)) {
+                    fs.mkdirSync(destDirPath, { recursive: true });
+                }
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+    copyDir(sourceDir, targetDir);
+}
+/**
+ * Copies all files from srcDir into <destRoot>/pastelsdd/context/, skipping files that already exist.
+ * Creates the destination directory if needed.
+ */
+export function copyContextDocs(destRoot, srcDir) {
+    if (!fs.existsSync(srcDir))
+        return;
+    const contextDir = path.join(destRoot, 'pastelsdd', 'context');
+    if (!fs.existsSync(contextDir)) {
+        fs.mkdirSync(contextDir, { recursive: true });
+    }
+    const files = fs.readdirSync(srcDir);
+    for (const file of files) {
+        const src = path.join(srcDir, file);
+        const dest = path.join(contextDir, file);
+        if (fs.existsSync(dest)) {
+            console.log(`  ${file} já existe — pulado`);
+            continue;
+        }
+        fs.copyFileSync(src, dest);
+    }
+}
+export function installDixiClaudeMd(projectDir, family) {
+    const currentFile = fileURLToPath(import.meta.url);
+    const packageRoot = path.join(path.dirname(currentFile), '..', '..', '..');
+    const claudeRuntimeDir = path.join(packageRoot, 'pscode', 'content', 'dixi', 'claude-runtime');
+    let templateName;
+    if (family === 'java') {
+        templateName = 'CLAUDE.md.java.template';
+    }
+    else if (family === 'react') {
+        templateName = 'CLAUDE.md.react.template';
+    }
+    else {
+        templateName = 'CLAUDE.md.java.template';
+        console.log('Dixi: stack não detectada, instalando CLAUDE.md genérico (baseado em Java). ' +
+            'Edite .pscode-dixi.yaml para corrigir.');
+    }
+    const templatePath = path.join(claudeRuntimeDir, templateName);
+    const templateContent = fs.readFileSync(templatePath, 'utf-8');
+    const claudeMdPath = path.join(projectDir, 'CLAUDE.md');
+    const marker = '<!-- dixi-constitutional -->';
+    if (fs.existsSync(claudeMdPath)) {
+        const existing = fs.readFileSync(claudeMdPath, 'utf-8');
+        if (existing.includes(marker)) {
+            console.log('Dixi: CLAUDE.md já contém seção constitucional — pulando.');
+            return;
+        }
+        fs.writeFileSync(claudeMdPath, existing + '\n' + templateContent, { encoding: 'utf-8' });
+    }
+    else {
+        fs.writeFileSync(claudeMdPath, templateContent, { encoding: 'utf-8' });
+    }
+}
+const PSTLD_COMMANDS_SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'pscode', 'content', 'dixi', 'claude-runtime', 'commands');
+const PSTLD_SKILLS_SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'pscode', 'content', 'dixi', 'claude-runtime', 'skills');
+const HOOKS_SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'pscode', 'content', 'dixi', 'claude-runtime', 'hooks');
+const DIXI_HOOK_ENTRIES = [
+    { event: 'PreToolUse', matcher: 'Edit|Write', command: 'node .claude/hooks/arch-guard.mjs' },
+    { event: 'UserPromptSubmit', matcher: null, command: 'node .claude/hooks/jira-context.mjs' },
+];
+function mergeSettingsHooks(settingsPath) {
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        }
+        catch (e) {
+            console.log(`Dixi: settings.json inválido — criando novo arquivo. (${e instanceof Error ? e.message : String(e)})`);
+            settings = {};
+        }
+    }
+    if (!settings.hooks || typeof settings.hooks !== 'object' || Array.isArray(settings.hooks)) {
+        settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    for (const { event, matcher, command } of DIXI_HOOK_ENTRIES) {
+        if (!Array.isArray(hooks[event])) {
+            hooks[event] = [];
+        }
+        const eventHooks = hooks[event];
+        const alreadyExists = eventHooks.some(entry => Array.isArray(entry.hooks) && entry.hooks.some(h => h.command === command));
+        if (!alreadyExists) {
+            const entry = {
+                hooks: [{ type: 'command', command }],
+            };
+            if (matcher)
+                entry.matcher = matcher;
+            eventHooks.push(entry);
+        }
+    }
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { encoding: 'utf-8' });
+}
+const ARCHITECTURES_BASE = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'pscode', 'content', 'dixi', 'architectures');
+// Task 3.2
+export function detectBasePackage(projectRoot) {
+    const pomPath = path.join(projectRoot, 'pom.xml');
+    if (!fs.existsSync(pomPath)) {
+        console.log('[dixi] detectBasePackage: pom.xml não encontrado — usando fallback com.example.app. Ajuste manualmente o basePackage no ArchitectureTest.java gerado.');
+        return 'com.example.app';
+    }
+    const pomContent = fs.readFileSync(pomPath, 'utf-8');
+    const groupIdMatch = pomContent.match(/<groupId>([^<]+)<\/groupId>/);
+    const artifactIdMatch = pomContent.match(/<artifactId>([^<]+)<\/artifactId>/);
+    if (!groupIdMatch || !artifactIdMatch) {
+        console.log('[dixi] detectBasePackage: groupId ou artifactId não encontrado no pom.xml — usando fallback com.example.app.');
+        return 'com.example.app';
+    }
+    const groupId = groupIdMatch[1].trim();
+    const artifactId = artifactIdMatch[1].trim().replace(/-/g, '');
+    return `${groupId}.${artifactId}`;
+}
+// Task 3.1
+export function applyHexagonalSkeleton(projectRoot, basePackage) {
+    const skeletonPath = path.join(ARCHITECTURES_BASE, 'hexagonal-spring', 'skeleton.yaml');
+    if (!fs.existsSync(skeletonPath))
+        return { created: 0, skipped: 0 };
+    const skeletonData = parseYaml(fs.readFileSync(skeletonPath, 'utf-8'));
+    const basePackageDir = basePackage.replace(/\./g, '/');
+    let created = 0;
+    let skipped = 0;
+    for (const dir of skeletonData.dirs) {
+        const resolvedDir = dir.replace('{basePackageDir}', basePackageDir);
+        const dirPath = path.join(projectRoot, resolvedDir);
+        const gitkeepPath = path.join(dirPath, '.gitkeep');
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+        if (!fs.existsSync(gitkeepPath)) {
+            fs.writeFileSync(gitkeepPath, '');
+            created++;
+        }
+        else {
+            skipped++;
+        }
+    }
+    return { created, skipped };
+}
+// Task 3.3
+export function generateArchitectureTest(projectRoot, basePackage) {
+    const templatePath = path.join(ARCHITECTURES_BASE, 'hexagonal-spring', 'ArchitectureTest.java.template');
+    if (!fs.existsSync(templatePath))
+        return false;
+    const basePackageDir = basePackage.replace(/\./g, '/');
+    const destDir = path.join(projectRoot, 'src', 'test', 'java', basePackageDir);
+    const destPath = path.join(destDir, 'ArchitectureTest.java');
+    if (fs.existsSync(destPath)) {
+        console.log('[dixi] ArchitectureTest.java: arquivo existente — ignorado');
+        return false;
+    }
+    const template = fs.readFileSync(templatePath, 'utf-8');
+    const content = template.replace(/\{basePackage\}/g, basePackage);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    fs.writeFileSync(destPath, content, { encoding: 'utf-8' });
+    return true;
+}
+// Task 3.4
+export function applyFeatureSlicedSkeleton(projectRoot) {
+    const skeletonPath = path.join(ARCHITECTURES_BASE, 'feature-sliced-react', 'skeleton.yaml');
+    if (!fs.existsSync(skeletonPath))
+        return { created: 0, skipped: 0 };
+    const skeletonData = parseYaml(fs.readFileSync(skeletonPath, 'utf-8'));
+    const readmeTemplatePath = path.join(ARCHITECTURES_BASE, 'feature-sliced-react', 'features', 'README.md.template');
+    let created = 0;
+    let skipped = 0;
+    for (const dir of skeletonData.dirs) {
+        const dirPath = path.join(projectRoot, dir);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+        if (dir.endsWith('features')) {
+            const readmePath = path.join(dirPath, 'README.md');
+            if (!fs.existsSync(readmePath) && fs.existsSync(readmeTemplatePath)) {
+                fs.copyFileSync(readmeTemplatePath, readmePath);
+                created++;
+            }
+            else {
+                skipped++;
+            }
+        }
+        else {
+            const gitkeepPath = path.join(dirPath, '.gitkeep');
+            if (!fs.existsSync(gitkeepPath)) {
+                fs.writeFileSync(gitkeepPath, '');
+                created++;
+            }
+            else {
+                skipped++;
+            }
+        }
+    }
+    return { created, skipped };
+}
+// Task 3.5
+export function installEslintArchitectureTemplate(projectRoot) {
+    const templatePath = path.join(ARCHITECTURES_BASE, 'feature-sliced-react', 'eslint-architecture.mjs.template');
+    if (!fs.existsSync(templatePath))
+        return;
+    const destPath = path.join(projectRoot, 'eslint-architecture.mjs');
+    if (!fs.existsSync(destPath)) {
+        fs.copyFileSync(templatePath, destPath);
+    }
+    console.log('\n[dixi] eslint-architecture.mjs instalado.\n' +
+        '  Para ativar as regras arquiteturais, adicione ao seu eslint.config.js:\n\n' +
+        '    import architectureRules from \'./eslint-architecture.mjs\';\n' +
+        '    export default [...existingConfig, ...architectureRules];\n');
+}
+export function installDixiExtras(projectDir, stack) {
+    const family = getDixiStackFamily(stack);
+    // Resolve package content root: dist/core/presets/ → package root → pscode/content/dixi/
+    const currentFile = fileURLToPath(import.meta.url);
+    const packageRoot = path.join(path.dirname(currentFile), '..', '..', '..');
+    const contentBase = path.join(packageRoot, 'pscode', 'content', 'dixi', 'context');
+    const kitBase = path.join(packageRoot, 'pscode', 'content', 'dixi', 'kit');
+    // Task 4.5: Ensure pastelsdd/context/ exists in the client repo
+    const contextDir = path.join(projectDir, 'pastelsdd', 'context');
+    if (!fs.existsSync(contextDir)) {
+        fs.mkdirSync(contextDir, { recursive: true });
+    }
+    // Task 4.2: Always copy shared/ docs
+    copyContextDocs(projectDir, path.join(contentBase, 'shared'));
+    if (family === null || family === 'node') {
+        console.log('Dixi: Stack não detectada — apenas docs compartilhados instalados. ' +
+            'Configure `family` em `.pscode-dixi.yaml` para instalar docs específicos de stack.');
+    }
+    // Task 4.3: Copy java/ only for Java projects
+    if (family === 'java') {
+        copyContextDocs(projectDir, path.join(contentBase, 'java'));
+    }
+    // Task 4.4: Copy react/ only for React projects
+    if (family === 'react') {
+        copyContextDocs(projectDir, path.join(contentBase, 'react'));
+    }
+    // Task 4.2: Copy shared SDLC kit (always) — PR template always overwritten
+    copyKitFiles(path.join(kitBase, 'shared'), projectDir, {
+        overwrite: ['pull_request_template.md'],
+    });
+    // Task 4.3: Copy java SDLC kit
+    if (family === 'java') {
+        copyKitFiles(path.join(kitBase, 'java'), projectDir);
+        console.log('\nDixi [Java kit instalado]:\n' +
+            '  Adicione ao pom.xml:\n' +
+            '    • plugin commitlint: npm install --save-dev @commitlint/cli @commitlint/config-conventional commitlint-plugin-jira-rules\n' +
+            '    • plugin Jacoco: <groupId>org.jacoco</groupId><artifactId>jacoco-maven-plugin</artifactId>\n' +
+            '    • plugin Husky (se gerenciado via frontend): npx husky install\n' +
+            '  Atenção: o job archunit requer ArchitectureTest.java (gerado pelo pscode init skeleton).');
+    }
+    // Task 4.4: Copy react SDLC kit
+    if (family === 'react') {
+        copyKitFiles(path.join(kitBase, 'react'), projectDir);
+        console.log('\nDixi [React kit instalado]:\n' +
+            '  Execute:\n' +
+            '    npm install --save-dev @commitlint/cli @commitlint/config-conventional commitlint-plugin-jira-rules husky lint-staged prettier eslint\n' +
+            '    npx husky install\n' +
+            '  Adicione ao package.json: "prepare": "husky install"');
+    }
+    installDixiClaudeMd(projectDir, family);
+    // Task 3.6 + 3.7: Apply architectural skeleton by stack
+    if (family === 'java') {
+        const basePackage = detectBasePackage(projectDir);
+        const skeletonResult = applyHexagonalSkeleton(projectDir, basePackage);
+        console.log(`[dixi] skeleton hexagonal: ${skeletonResult.created} diretórios criados, ${skeletonResult.skipped} ignorados`);
+        const archTestCreated = generateArchitectureTest(projectDir, basePackage);
+        console.log(`[dixi] ArchitectureTest.java: ${archTestCreated ? 'criado' : 'ignorado (já existe)'}`);
+    }
+    else if (family === 'react') {
+        const skeletonResult = applyFeatureSlicedSkeleton(projectDir);
+        console.log(`[dixi] skeleton feature-sliced: ${skeletonResult.created} arquivos criados, ${skeletonResult.skipped} ignorados`);
+        installEslintArchitectureTemplate(projectDir);
+    }
+    else {
+        console.log('[dixi] skeleton arquitetural: stack não reconhecida — skeleton não disponível para esta stack');
+    }
+    // Copy /pstld:* slash commands to .claude/commands/pstld/ (idempotent — overwrites)
+    const pstldCommandsDir = path.join(projectDir, '.claude', 'commands', 'pstld');
+    if (!fs.existsSync(pstldCommandsDir)) {
+        fs.mkdirSync(pstldCommandsDir, { recursive: true });
+    }
+    if (fs.existsSync(PSTLD_COMMANDS_SRC)) {
+        const files = fs.readdirSync(PSTLD_COMMANDS_SRC);
+        for (const file of files) {
+            fs.copyFileSync(path.join(PSTLD_COMMANDS_SRC, file), path.join(pstldCommandsDir, file));
+        }
+    }
+    // Copy pstld-* skills to .claude/skills/<name>/SKILL.md (idempotent — overwrites)
+    if (fs.existsSync(PSTLD_SKILLS_SRC)) {
+        const skillFiles = fs.readdirSync(PSTLD_SKILLS_SRC).filter(f => f.endsWith('.md'));
+        for (const file of skillFiles) {
+            const skillName = file.replace(/\.md$/, '');
+            const skillDir = path.join(projectDir, '.claude', 'skills', skillName);
+            if (!fs.existsSync(skillDir)) {
+                fs.mkdirSync(skillDir, { recursive: true });
+            }
+            fs.copyFileSync(path.join(PSTLD_SKILLS_SRC, file), path.join(skillDir, 'SKILL.md'));
+        }
+    }
+    // Copy hooks to .claude/hooks/ (brownfield-safe: skip if file already exists)
+    const hooksDestDir = path.join(projectDir, '.claude', 'hooks');
+    if (!fs.existsSync(hooksDestDir)) {
+        fs.mkdirSync(hooksDestDir, { recursive: true });
+    }
+    if (fs.existsSync(HOOKS_SRC)) {
+        const hookFiles = fs.readdirSync(HOOKS_SRC).filter(f => f.endsWith('.mjs'));
+        for (const file of hookFiles) {
+            const dest = path.join(hooksDestDir, file);
+            if (!fs.existsSync(dest)) {
+                fs.copyFileSync(path.join(HOOKS_SRC, file), dest);
+            }
+        }
+    }
+    // Merge .claude/settings.json with hook registrations (never overwrite existing config)
+    mergeSettingsHooks(path.join(projectDir, '.claude', 'settings.json'));
+}
+//# sourceMappingURL=dixi.js.map

package/dist/core/profile-sync-drift.js

@@ -13,8 +13,7 @@ export const WORKFLOW_TO_SKILL_DIR = {
     'continue': 'pscode-continue-change',
     'apply': 'pscode-apply-change',
     'ff': 'pscode-ff-change',
-    'sync': 'pscode-sync-specs',
-    'archive': 'pscode-archive-change',
+    'complete': 'pscode-archive-change',
     'bulk-archive': 'pscode-bulk-archive-change',
     'verify': 'pscode-verify-change',
     'onboard': 'pscode-onboard',
@@ -22,6 +21,14 @@ export const WORKFLOW_TO_SKILL_DIR = {
     // Trello-specific workflows
     'trello-setup': 'pscode-trello-setup',
     'draft': 'pscode-trello-draft',
+    // Dixi-specific workflows
+    'rfc': 'pscode-dixi-rfc',
+    'design': 'pscode-dixi-design',
+    'tasks': 'pscode-dixi-tasks',
+    'arch-check': 'pscode-dixi-arch-check',
+    'adr': 'pscode-dixi-adr',
+    'jira-sync': 'pscode-dixi-jira-sync',
+    'dod': 'pscode-dixi-dod',
 };
 function toKnownWorkflows(workflows) {
     return workflows.filter((workflow) => ALL_WORKFLOWS.includes(workflow));

package/dist/core/profiles.d.ts

@@ -1,26 +1,28 @@
 /**
- * Profile System
+ * Predefined Workflow Profiles
  *
- * Defines workflow profiles that control which workflows are installed.
- * Profiles determine WHICH workflows; delivery (in global config) determines HOW.
+ * Add, remove or edit profiles here. Users select a profile via
+ * `pscode init --profile <name>` or `pscode config profile <name>`.
+ * The workflow lists are fixed in code — users cannot customise them.
  */
-import type { Profile } from './global-config.js';
-/**
- * Core workflows included in the 'core' profile.
- * These provide the streamlined experience for new users.
- */
-export declare const CORE_WORKFLOWS: readonly ["propose", "explore", "apply", "sync", "archive"];
-/**
- * All available workflows in the system.
- */
-export declare const ALL_WORKFLOWS: readonly ["propose", "explore", "new", "continue", "apply", "ff", "sync", "archive", "bulk-archive", "verify", "onboard", "trello-setup", "draft"];
+export declare const ALL_WORKFLOWS: readonly ["propose", "explore", "new", "continue", "apply", "ff", "complete", "bulk-archive", "verify", "onboard", "trello-setup", "draft", "rfc", "design", "tasks", "arch-check", "adr", "jira-sync", "dod"];
 export type WorkflowId = (typeof ALL_WORKFLOWS)[number];
-export type CoreWorkflowId = (typeof CORE_WORKFLOWS)[number];
-/**
- * Resolves which workflows should be active for a given profile configuration.
- *
- * - 'core' profile always returns CORE_WORKFLOWS
- * - 'custom' profile returns the provided customWorkflows, or empty array if not provided
- */
-export declare function getProfileWorkflows(profile: Profile, customWorkflows?: string[]): readonly string[];
+export interface ProfileDefinition {
+    description: string;
+    workflows: readonly WorkflowId[];
+}
+export declare const PROFILES: {
+    readonly standard: {
+        readonly description: "Padrão — propose, explore, apply, complete";
+        readonly workflows: readonly ["propose", "explore", "apply", "complete"];
+    };
+    readonly dixi: {
+        readonly description: "Dixi — RFC→Design→Tasks→Apply com guardrails para Java/Spring e React/Next.js";
+        readonly workflows: readonly ["rfc", "design", "tasks", "apply", "arch-check", "adr", "jira-sync", "dod"];
+    };
+};
+export type ProfileName = keyof typeof PROFILES;
+export declare const DEFAULT_PROFILE: ProfileName;
+export declare function getProfileWorkflows(profile: ProfileName): readonly WorkflowId[];
+export declare function isValidProfile(name: string): name is ProfileName;
 //# sourceMappingURL=profiles.d.ts.map