aios-core 4.2.15 → 4.4.0

package/packages/installer/tests/unit/artifact-copy-pipeline/artifact-copy-pipeline.test.js

@@ -0,0 +1,271 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const {
+  copySkillFiles,
+  copyExtraCommandFiles,
+  createClaudeSettingsLocal,
+} = require('../../../../../packages/installer/src/wizard/ide-config-generator');
+
+function createTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'artifact-copy-'));
+}
+
+function cleanup(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+describe('artifact-copy-pipeline (Story INS-4.3)', () => {
+  describe('copySkillFiles', () => {
+    test('copies skill directories from source to target via real function', async () => {
+      const sourceRoot = createTempDir();
+      const targetRoot = createTempDir();
+
+      try {
+        // Create source skills
+        const skillsDir = path.join(sourceRoot, '.claude', 'skills');
+        for (const skill of ['skill-a', 'skill-b', 'skill-c']) {
+          const dir = path.join(skillsDir, skill);
+          fs.mkdirSync(dir, { recursive: true });
+          fs.writeFileSync(path.join(dir, 'SKILL.md'), `# ${skill}`, 'utf8');
+        }
+
+        // Call the REAL exported function with _sourceRoot override
+        const result = await copySkillFiles(targetRoot, sourceRoot);
+
+        expect(result.count).toBe(3);
+        expect(result.skipped).toBe(false);
+
+        // Verify files actually copied to target
+        const targetSkills = path.join(targetRoot, '.claude', 'skills');
+        const copied = fs.readdirSync(targetSkills);
+        expect(copied).toContain('skill-a');
+        expect(copied).toContain('skill-b');
+        expect(copied).toContain('skill-c');
+        expect(copied.length).toBe(3);
+
+        // Verify SKILL.md content preserved
+        const skillMd = fs.readFileSync(path.join(targetSkills, 'skill-a', 'SKILL.md'), 'utf8');
+        expect(skillMd).toBe('# skill-a');
+      } finally {
+        cleanup(sourceRoot);
+        cleanup(targetRoot);
+      }
+    });
+
+    test('returns skipped when source does not exist', async () => {
+      const targetRoot = createTempDir();
+      const fakeSourceRoot = path.join(os.tmpdir(), 'nonexistent-source-' + Date.now());
+
+      try {
+        // Call the REAL function with a non-existent source
+        const result = await copySkillFiles(targetRoot, fakeSourceRoot);
+
+        expect(result.skipped).toBe(true);
+        expect(result.count).toBe(0);
+      } finally {
+        cleanup(targetRoot);
+      }
+    });
+
+    test('copy is idempotent — re-copy overwrites without corruption', async () => {
+      const sourceRoot = createTempDir();
+      const targetRoot = createTempDir();
+
+      try {
+        const skillsDir = path.join(sourceRoot, '.claude', 'skills', 'test-skill');
+        fs.mkdirSync(skillsDir, { recursive: true });
+        fs.writeFileSync(path.join(skillsDir, 'SKILL.md'), '# v1', 'utf8');
+
+        // First copy
+        await copySkillFiles(targetRoot, sourceRoot);
+
+        // Update source to v2
+        fs.writeFileSync(path.join(skillsDir, 'SKILL.md'), '# v2', 'utf8');
+
+        // Second copy (idempotent overwrite)
+        const result = await copySkillFiles(targetRoot, sourceRoot);
+
+        expect(result.count).toBe(1);
+        const content = fs.readFileSync(
+          path.join(targetRoot, '.claude', 'skills', 'test-skill', 'SKILL.md'),
+          'utf8'
+        );
+        expect(content).toBe('# v2');
+      } finally {
+        cleanup(sourceRoot);
+        cleanup(targetRoot);
+      }
+    });
+  });
+
+  describe('copyExtraCommandFiles', () => {
+    test('copies .md files recursively excluding AIOS/agents/ via real function', async () => {
+      const sourceRoot = createTempDir();
+      const targetRoot = createTempDir();
+
+      try {
+        const cmdDir = path.join(sourceRoot, '.claude', 'commands');
+
+        // Create greet.md (root level)
+        fs.mkdirSync(cmdDir, { recursive: true });
+        fs.writeFileSync(path.join(cmdDir, 'greet.md'), '# Greet', 'utf8');
+
+        // Create synapse/manager.md
+        const synapseDir = path.join(cmdDir, 'synapse');
+        fs.mkdirSync(synapseDir, { recursive: true });
+        fs.writeFileSync(path.join(synapseDir, 'manager.md'), '# Manager', 'utf8');
+
+        // Create synapse/tasks/add-rule.md
+        const tasksDir = path.join(synapseDir, 'tasks');
+        fs.mkdirSync(tasksDir, { recursive: true });
+        fs.writeFileSync(path.join(tasksDir, 'add-rule.md'), '# Add Rule', 'utf8');
+
+        // Create AIOS/agents/dev.md (should be EXCLUDED)
+        const agentsDir = path.join(cmdDir, 'AIOS', 'agents');
+        fs.mkdirSync(agentsDir, { recursive: true });
+        fs.writeFileSync(path.join(agentsDir, 'dev.md'), '# Dev Agent', 'utf8');
+
+        // Create AIOS/stories/story.md (should be EXCLUDED — project-specific)
+        const storiesDir = path.join(cmdDir, 'AIOS', 'stories');
+        fs.mkdirSync(storiesDir, { recursive: true });
+        fs.writeFileSync(path.join(storiesDir, 'story.md'), '# Story', 'utf8');
+
+        // Create squad directory (should be EXCLUDED — private)
+        const squadDir = path.join(cmdDir, 'cohort-squad');
+        fs.mkdirSync(squadDir, { recursive: true });
+        fs.writeFileSync(path.join(squadDir, 'manager.md'), '# Squad', 'utf8');
+
+        // Call the REAL exported function with _sourceRoot override
+        const result = await copyExtraCommandFiles(targetRoot, sourceRoot);
+
+        expect(result.count).toBe(3); // greet.md, manager.md, add-rule.md
+        expect(result.skipped).toBe(false);
+
+        // Verify distributable entries copied
+        const targetCmd = path.join(targetRoot, '.claude', 'commands');
+        expect(fs.existsSync(path.join(targetCmd, 'greet.md'))).toBe(true);
+        expect(fs.existsSync(path.join(targetCmd, 'synapse', 'manager.md'))).toBe(true);
+        expect(fs.existsSync(path.join(targetCmd, 'synapse', 'tasks', 'add-rule.md'))).toBe(true);
+
+        // Verify AIOS/agents/ was excluded (handled by copyAgentFiles)
+        expect(fs.existsSync(path.join(targetCmd, 'AIOS', 'agents', 'dev.md'))).toBe(false);
+
+        // Verify AIOS/stories/ was excluded (project-specific)
+        expect(fs.existsSync(path.join(targetCmd, 'AIOS', 'stories', 'story.md'))).toBe(false);
+
+        // Verify squad directories not copied (private)
+        expect(fs.existsSync(path.join(targetCmd, 'cohort-squad'))).toBe(false);
+      } finally {
+        cleanup(sourceRoot);
+        cleanup(targetRoot);
+      }
+    });
+  });
+
+  describe('createClaudeSettingsLocal — hooks registration', () => {
+    test('registers ALL .cjs hooks in settings.local.json', async () => {
+      const tmpDir = createTempDir();
+
+      try {
+        // Create hooks directory with 2 .cjs files
+        const hooksDir = path.join(tmpDir, '.claude', 'hooks');
+        fs.mkdirSync(hooksDir, { recursive: true });
+        fs.writeFileSync(path.join(hooksDir, 'synapse-engine.cjs'), '// hook 1', 'utf8');
+        fs.writeFileSync(path.join(hooksDir, 'precompact-session-digest.cjs'), '// hook 2', 'utf8');
+        fs.writeFileSync(path.join(hooksDir, 'README.md'), '# Hooks', 'utf8');
+
+        const result = await createClaudeSettingsLocal(tmpDir);
+
+        expect(result).not.toBeNull();
+
+        const settingsContent = fs.readFileSync(path.join(tmpDir, '.claude', 'settings.local.json'), 'utf8');
+        const settings = JSON.parse(settingsContent);
+
+        // Should have hooks.UserPromptSubmit with 2 entries
+        expect(settings.hooks).toBeDefined();
+        expect(settings.hooks.UserPromptSubmit).toBeDefined();
+        expect(settings.hooks.UserPromptSubmit.length).toBe(2);
+
+        // Both hooks registered
+        const commands = settings.hooks.UserPromptSubmit.flatMap(entry =>
+          entry.hooks.map(h => h.command)
+        );
+        expect(commands.some(c => c.includes('synapse-engine'))).toBe(true);
+        expect(commands.some(c => c.includes('precompact-session-digest'))).toBe(true);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    test('returns null when no hooks directory exists', async () => {
+      const tmpDir = createTempDir();
+
+      try {
+        fs.mkdirSync(path.join(tmpDir, '.claude'), { recursive: true });
+        const result = await createClaudeSettingsLocal(tmpDir);
+        expect(result).toBeNull();
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    test('does not duplicate hooks on re-run (idempotent)', async () => {
+      const tmpDir = createTempDir();
+
+      try {
+        const hooksDir = path.join(tmpDir, '.claude', 'hooks');
+        fs.mkdirSync(hooksDir, { recursive: true });
+        fs.writeFileSync(path.join(hooksDir, 'synapse-engine.cjs'), '// hook', 'utf8');
+
+        // Run twice
+        await createClaudeSettingsLocal(tmpDir);
+        await createClaudeSettingsLocal(tmpDir);
+
+        const settingsContent = fs.readFileSync(path.join(tmpDir, '.claude', 'settings.local.json'), 'utf8');
+        const settings = JSON.parse(settingsContent);
+
+        // Should still have only 1 entry
+        expect(settings.hooks.UserPromptSubmit.length).toBe(1);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+
+    test('preserves existing settings when merging hooks', async () => {
+      const tmpDir = createTempDir();
+
+      try {
+        const hooksDir = path.join(tmpDir, '.claude', 'hooks');
+        fs.mkdirSync(hooksDir, { recursive: true });
+        fs.writeFileSync(path.join(hooksDir, 'synapse-engine.cjs'), '// hook', 'utf8');
+
+        // Create existing settings
+        const settingsPath = path.join(tmpDir, '.claude', 'settings.local.json');
+        fs.writeFileSync(settingsPath, JSON.stringify({ customKey: 'preserved' }, null, 2), 'utf8');
+
+        await createClaudeSettingsLocal(tmpDir);
+
+        const settingsContent = fs.readFileSync(settingsPath, 'utf8');
+        const settings = JSON.parse(settingsContent);
+
+        expect(settings.customKey).toBe('preserved');
+        expect(settings.hooks.UserPromptSubmit.length).toBe(1);
+      } finally {
+        cleanup(tmpDir);
+      }
+    });
+  });
+
+  describe('generator failure graceful degradation', () => {
+    test('generate-settings-json throws on missing config — install should catch', () => {
+      const { generate } = require('../../../../../.aios-core/infrastructure/scripts/generate-settings-json');
+
+      // Calling generate on a non-existent path should throw
+      expect(() => generate('/nonexistent/path')).toThrow();
+    });
+  });
+});

package/packages/installer/tests/unit/claude-md-template-v5/claude-md-template-v5.test.js

@@ -0,0 +1,192 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { MarkdownMerger } = require('../../../src/merger/strategies/markdown-merger.js');
+const {
+  parseMarkdownSections,
+  hasAiosMarkers,
+} = require('../../../src/merger/parsers/markdown-section-parser.js');
+
+const TEMPLATE_PATH = path.join(
+  __dirname, '..', '..', '..', '..', '..', '.aios-core',
+  'product', 'templates', 'ide-rules', 'claude-rules.md'
+);
+
+describe('CLAUDE.md Template v5 (Story INS-4.4)', () => {
+  let templateContent;
+
+  beforeAll(() => {
+    templateContent = fs.readFileSync(TEMPLATE_PATH, 'utf8');
+  });
+
+  describe('template has 4 new sections with AIOS-MANAGED markers', () => {
+    test('template file exists and has AIOS markers', () => {
+      expect(templateContent).toBeTruthy();
+      expect(hasAiosMarkers(templateContent)).toBe(true);
+    });
+
+    test('contains framework-boundary section', () => {
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: framework-boundary -->');
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-END: framework-boundary -->');
+      expect(templateContent).toContain('## Framework vs Project Boundary');
+    });
+
+    test('contains rules-system section', () => {
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: rules-system -->');
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-END: rules-system -->');
+      expect(templateContent).toContain('## Rules System');
+    });
+
+    test('contains code-intelligence section', () => {
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: code-intelligence -->');
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-END: code-intelligence -->');
+      expect(templateContent).toContain('## Code Intelligence');
+    });
+
+    test('contains graph-dashboard section', () => {
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: graph-dashboard -->');
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-END: graph-dashboard -->');
+      expect(templateContent).toContain('## Graph Dashboard');
+    });
+
+    test('template has exactly 11 AIOS-MANAGED sections total', () => {
+      const startMatches = templateContent.match(/<!-- AIOS-MANAGED-START:/g);
+      const endMatches = templateContent.match(/<!-- AIOS-MANAGED-END:/g);
+      expect(startMatches.length).toBe(11);
+      expect(endMatches.length).toBe(11);
+    });
+  });
+
+  describe('section content quality', () => {
+    test('framework-boundary has L1-L4 table', () => {
+      expect(templateContent).toContain('**L1** Framework Core');
+      expect(templateContent).toContain('**L2** Framework Templates');
+      expect(templateContent).toContain('**L3** Project Config');
+      expect(templateContent).toContain('**L4** Project Runtime');
+      expect(templateContent).toContain('frameworkProtection');
+    });
+
+    test('rules-system lists all 8 rule files', () => {
+      const ruleFiles = [
+        'agent-authority.md',
+        'agent-handoff.md',
+        'agent-memory-imports.md',
+        'coderabbit-integration.md',
+        'ids-principles.md',
+        'mcp-usage.md',
+        'story-lifecycle.md',
+        'workflow-execution.md',
+      ];
+      for (const file of ruleFiles) {
+        expect(templateContent).toContain(file);
+      }
+    });
+
+    test('code-intelligence has provider status table', () => {
+      expect(templateContent).toContain('**Configured**');
+      expect(templateContent).toContain('**Fallback**');
+      expect(templateContent).toContain('**Disabled**');
+      expect(templateContent).toContain('isCodeIntelAvailable()');
+    });
+
+    test('graph-dashboard has CLI commands', () => {
+      expect(templateContent).toContain('aios graph --deps');
+      expect(templateContent).toContain('--format=json');
+      expect(templateContent).toContain('--format=html');
+      expect(templateContent).toContain('--watch');
+      expect(templateContent).toContain('aios graph --stats');
+    });
+  });
+
+  describe('existing sections preserved', () => {
+    test('original 5 AIOS-MANAGED sections still present', () => {
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: core-framework -->');
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: agent-system -->');
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: framework-structure -->');
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: aios-patterns -->');
+      expect(templateContent).toContain('<!-- AIOS-MANAGED-START: common-commands -->');
+    });
+
+    test('non-managed sections still present', () => {
+      expect(templateContent).toContain('## Development Methodology');
+      expect(templateContent).toContain('## Workflow Execution');
+      expect(templateContent).toContain('## Best Practices');
+      expect(templateContent).toContain('## Debugging');
+    });
+  });
+
+  describe('upgrade: new sections added to existing CLAUDE.md', () => {
+    let merger;
+
+    beforeEach(() => {
+      merger = new MarkdownMerger();
+    });
+
+    test('upgrade adds 4 new sections to CLAUDE.md without them', async () => {
+      const existingClaudeMd = `# Synkra AIOS
+
+<!-- AIOS-MANAGED-START: core-framework -->
+## Core Framework Understanding
+Old core content
+<!-- AIOS-MANAGED-END: core-framework -->
+
+## My Custom Section
+User content that must be preserved`;
+
+      const result = await merger.merge(existingClaudeMd, templateContent);
+
+      // New sections added
+      expect(result.content).toContain('## Framework vs Project Boundary');
+      expect(result.content).toContain('## Rules System');
+      expect(result.content).toContain('## Code Intelligence');
+      expect(result.content).toContain('## Graph Dashboard');
+
+      // User content preserved
+      expect(result.content).toContain('## My Custom Section');
+      expect(result.content).toContain('User content that must be preserved');
+
+      // Stats reflect additions
+      expect(result.stats.added).toBeGreaterThanOrEqual(4);
+    });
+
+    test('upgrade preserves custom PROJECT-CUSTOMIZED content', async () => {
+      const existingClaudeMd = `# My Project Rules
+
+<!-- AIOS-MANAGED-START: core-framework -->
+## Core Framework Understanding
+Core content
+<!-- AIOS-MANAGED-END: core-framework -->
+
+## Padroes de Codigo
+My custom coding standards here
+
+## Testes & Quality Gates
+My custom testing rules`;
+
+      const result = await merger.merge(existingClaudeMd, templateContent);
+
+      // Custom sections preserved
+      expect(result.content).toContain('## Padroes de Codigo');
+      expect(result.content).toContain('My custom coding standards here');
+      expect(result.content).toContain('## Testes & Quality Gates');
+      expect(result.content).toContain('My custom testing rules');
+
+      // Managed sections updated
+      expect(result.content).toContain('<!-- AIOS-MANAGED-START: framework-boundary -->');
+    });
+  });
+
+  describe('section order in template', () => {
+    test('4 new sections come after framework-structure and before workflow-execution', () => {
+      const frameworkStructureEnd = templateContent.indexOf('<!-- AIOS-MANAGED-END: framework-structure -->');
+      const frameworkBoundaryStart = templateContent.indexOf('<!-- AIOS-MANAGED-START: framework-boundary -->');
+      const graphDashboardEnd = templateContent.indexOf('<!-- AIOS-MANAGED-END: graph-dashboard -->');
+      const workflowExecution = templateContent.indexOf('## Workflow Execution');
+
+      expect(frameworkStructureEnd).toBeLessThan(frameworkBoundaryStart);
+      expect(frameworkBoundaryStart).toBeLessThan(graphDashboardEnd);
+      expect(graphDashboardEnd).toBeLessThan(workflowExecution);
+    });
+  });
+});