project-iris 0.0.1

package/src/iris_bundle/frameworks/iris-core/src/__tests__/unit/flow-consistency/placeholder-consistency.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Placeholder Consistency Tests
+ *
+ * Tests that templates use placeholder notation like {NNN}, {UUU}, {SSS}
+ * instead of hardcoded values like 001, 002, etc.
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import * as path from 'path';
+import { glob } from 'glob';
+import * as fs from 'fs-extra';
+import { ValidationIssues, readFlowFile } from './helpers';
+
+const FLOWS_PATH = path.resolve(__dirname, '../../../../../flows/aidlc');
+
+let templateFiles: string[] = [];
+
+beforeAll(async () => {
+  templateFiles = await glob(path.join(FLOWS_PATH, 'templates/**/*.md'));
+});
+
+describe('Flow Files - Placeholder Consistency', () => {
+
+  describe('Templates should use placeholder notation', () => {
+    const patterns = [
+      { name: 'intent', regex: /intent:\s*['"]?00\d-/g, placeholder: '{NNN}-' },
+      { name: 'unit', regex: /unit:\s*['"]?00\d-/g, placeholder: '{UUU}-' },
+    ];
+
+    for (const { name, regex, placeholder } of patterns) {
+      it(`should use ${placeholder} not hardcoded 001- for ${name} in examples`, async () => {
+        const issues = new ValidationIssues('Placeholder issues');
+
+        for (const file of templateFiles) {
+          const content = await fs.readFile(file, 'utf8');
+          const lines = content.split('\n');
+
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              // Skip if in Example section (concrete numbers are OK there)
+              const beforeLines = lines.slice(Math.max(0, i - 20), i).join('\n');
+              if (!beforeLines.includes('## Example')) {
+                issues.addWithLine(file, i, `found hardcoded ${name} pattern, expected ${placeholder}`);
+              }
+            }
+          }
+        }
+
+        issues.log();
+        issues.assertNone(expect);
+      });
+    }
+
+    it('should use {SSS} for story IDs in templates', async () => {
+      const content = await readFlowFile('templates/inception/story-template.md');
+      expect(content).toMatch(/\{SSS\}-\{title-slug\}/);
+    });
+
+    it('should use {bolt-id} for bolt IDs in templates', async () => {
+      const content = await readFlowFile('templates/construction/bolt-template.md');
+      expect(content).toMatch(/\{bolt-id\}/);
+    });
+  });
+
+  describe('Skills should use consistent placeholder names', () => {
+    it('should use {bolt-id} consistently', async () => {
+      const content = await readFlowFile('skills/construction/bolt-start.md');
+      expect(content).toMatch(/\{bolt-id\}/g);
+    });
+
+    it('should use {intent} not {intent-name} in path references', async () => {
+      const content = await readFlowFile('skills/inception/units.md');
+      expect(content).toMatch(/\{intent\}/);
+    });
+  });
+});

package/src/iris_bundle/frameworks/iris-core/src/__tests__/unit/flow-consistency/reference-integrity.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Reference Integrity Tests
+ *
+ * Tests that skills reference files that actually exist:
+ * - Scripts referenced by skills exist
+ * - Templates referenced by skills exist
+ * - Schema files referenced by skills exist
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import * as path from 'path';
+import { glob } from 'glob';
+import * as fs from 'fs-extra';
+import { ValidationIssues, readFlowFile } from './helpers';
+
+const ROOT_DIR = path.resolve(__dirname, '../../..');
+const FLOWS_PATH = path.join(ROOT_DIR, 'flows/aidlc');
+const SCRIPTS_PATH = path.join(ROOT_DIR, 'scripts');
+
+let skillFiles: string[] = [];
+
+beforeAll(async () => {
+  skillFiles = await glob(path.join(FLOWS_PATH, 'skills/**/*.md'));
+});
+
+describe('Flow Files - Reference Integrity', () => {
+
+  describe('Skills should reference existing scripts', () => {
+    it('bolt-start.md should reference existing bolt-complete.js', async () => {
+      const content = await readFlowFile('skills/construction/bolt-start.md');
+
+      expect(content).toMatch(/bolt-complete\.js/);
+
+      const scriptPath = path.join(SCRIPTS_PATH, 'bolt-complete.js');
+      const exists = await fs.pathExists(scriptPath);
+
+      if (!exists) {
+        console.error(`\nMissing script: ${scriptPath}`);
+      }
+
+      expect(exists).toBe(true);
+    });
+  });
+
+  describe('Skills should reference existing templates', () => {
+    const templateRefs: Record<string, { template: string; dir: string }> = {
+      'units.md': { template: 'unit-brief-template.md', dir: 'inception' },
+      'story-create.md': { template: 'story-template.md', dir: 'inception' },
+      'bolt-plan.md': { template: 'bolt-template.md', dir: 'construction' },
+      'requirements.md': { template: 'requirements-template.md', dir: 'inception' },
+    };
+
+    for (const [skillFile, { template, dir }] of Object.entries(templateRefs)) {
+      it(`${skillFile} should reference ${template}`, async () => {
+        const matchingSkills = skillFiles.filter(f => f.endsWith(skillFile));
+
+        if (matchingSkills.length === 0) {
+          return; // Skip if skill doesn't exist
+        }
+
+        const content = await fs.readFile(matchingSkills[0], 'utf8');
+        expect(content).toMatch(template);
+
+        const templatePath = path.join(FLOWS_PATH, 'templates', dir, template);
+        const exists = await fs.pathExists(templatePath);
+
+        if (!exists) {
+          console.error(`\nMissing template: ${templatePath}`);
+        }
+
+        expect(exists).toBe(true);
+      });
+    }
+  });
+
+  describe('Skills should reference existing schema files', () => {
+    const schemas = ['memory-bank.yaml', 'context-config.yaml'];
+
+    for (const schema of schemas) {
+      it(`${schema} should exist`, async () => {
+        const schemaPath = path.join(FLOWS_PATH, schema);
+        const exists = await fs.pathExists(schemaPath);
+
+        if (!exists) {
+          console.error(`\nMissing schema: ${schemaPath}`);
+        }
+
+        expect(exists).toBe(true);
+      });
+    }
+  });
+});

package/src/iris_bundle/frameworks/iris-core/src/__tests__/unit/flow-consistency/terminology-consistency.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Terminology Consistency Tests
+ *
+ * Tests that terminology is used consistently across flow files:
+ * - Phase names (inception, construction, operations) use consistent casing
+ * - Artifact type names use consistent casing
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import * as path from 'path';
+import { glob } from 'glob';
+import * as fs from 'fs-extra';
+import { readFlowFile } from './helpers';
+
+const FLOWS_PATH = path.resolve(__dirname, '../../../../../flows/aidlc');
+
+let skillFiles: string[] = [];
+let agentFiles: string[] = [];
+let templateFiles: string[] = [];
+
+beforeAll(async () => {
+  skillFiles = await glob(path.join(FLOWS_PATH, 'skills/**/*.md'));
+  agentFiles = await glob(path.join(FLOWS_PATH, 'agents/**/*.md'));
+  templateFiles = await glob(path.join(FLOWS_PATH, 'templates/**/*.md'));
+});
+
+describe('Flow Files - Terminology Consistency', () => {
+
+  describe('Phase names should be consistent', () => {
+    it('should use lowercase phase names in paths', async () => {
+      const allFiles = [...skillFiles, ...agentFiles, ...templateFiles];
+      const issues: string[] = [];
+
+      // Check for capitalized phase names in code/paths
+      const capitalInPath = /['"`/][Ii]nception['"`]/g;
+      const capitalInPath2 = /['"`/][Cc]onstruction['"`]/g;
+      const capitalInPath3 = /['"`/][Oo]perations['"`]/g;
+
+      for (const file of allFiles) {
+        const content = await fs.readFile(file, 'utf8');
+
+        for (const regex of [capitalInPath, capitalInPath2, capitalInPath3]) {
+          const lines = content.split('\n');
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i]) && (lines[i].includes('/') || lines[i].includes('skills/') || lines[i].includes('agents/'))) {
+              issues.push(`${path.relative(FLOWS_PATH, file)}:${i + 1}`);
+            }
+          }
+        }
+      }
+
+      // Log as warning (this is a soft check)
+      if (issues.length > 0) {
+        console.warn('\nTerminology warnings (phase name casing in paths):\n' + issues.join('\n'));
+      }
+    });
+  });
+
+  describe('Artifact type names should be consistent', () => {
+    it('should use consistent casing for artifact type names', async () => {
+      // This is a placeholder test - expand as needed
+      // Currently checks that "intent" is used in code contexts
+      const allFiles = [...skillFiles, ...agentFiles];
+
+      for (const file of allFiles) {
+        const content = await fs.readFile(file, 'utf8');
+        // Basic check - ensure we're not mixing "Intent" with "intent" in code blocks
+        // This could be expanded with more specific rules
+      }
+    });
+  });
+});

package/src/iris_bundle/frameworks/iris-core/src/__tests__/unit/schema-validation/markdown-schema.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import * as path from 'path';
+import { glob } from 'glob';
+import { loadSchema, validateFiles } from '../../../lib/markdown-validator';
+
+const FLOWS_PATH = path.resolve(__dirname, '../../../flows/aidlc');
+const SCHEMAS_PATH = path.resolve(__dirname, '../../schemas');
+
+describe('Flow Files Schema Validation', () => {
+  describe('Skill Files', () => {
+    let files: string[] = [];
+    const schema = loadSchema(path.join(SCHEMAS_PATH, 'skill.schema.yaml'));
+
+    beforeAll(async () => {
+      files = await glob(path.join(FLOWS_PATH, 'skills/**/*.md'));
+    });
+
+    it('should find skill files', () => {
+      expect(files.length).toBeGreaterThan(0);
+    });
+
+    it('should validate against schema', () => {
+      const { summary } = validateFiles(files, schema);
+
+      if (!summary.valid) {
+        console.error('Skill file errors:\n' + summary.errors.join('\n'));
+      }
+
+      expect(summary.valid).toBe(true);
+    });
+  });
+
+  describe('Agent Files', () => {
+    let files: string[] = [];
+    const schema = loadSchema(path.join(SCHEMAS_PATH, 'agent.schema.yaml'));
+
+    beforeAll(async () => {
+      files = await glob(path.join(FLOWS_PATH, 'agents/*.md'));
+    });
+
+    it('should find agent files', () => {
+      expect(files.length).toBeGreaterThan(0);
+    });
+
+    it('should validate against schema', () => {
+      const { summary } = validateFiles(files, schema);
+
+      if (!summary.valid) {
+        console.error('Agent file errors:\n' + summary.errors.join('\n'));
+      }
+
+      expect(summary.valid).toBe(true);
+    });
+  });
+});

package/src/iris_bundle/frameworks/iris-core/src/__tests__/unit/schema-validation/yaml-config-schema.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest';
+import * as path from 'path';
+import { loadYamlSchema, validateYamlFile } from '../../../lib/yaml-validator';
+
+const SCHEMAS_PATH = path.resolve(__dirname, '../../schemas');
+const FLOWS_PATH = path.resolve(__dirname, '../../../flows/aidlc');
+
+describe('YAML Config Schema Validation', () => {
+  describe('memory-bank.yaml', () => {
+    const schema = loadYamlSchema(path.join(SCHEMAS_PATH, 'memory-bank.schema.yaml'));
+    const configPath = path.join(FLOWS_PATH, 'memory-bank.yaml');
+
+    it('should validate successfully', () => {
+      const result = validateYamlFile(configPath, schema);
+
+      if (!result.valid) {
+        console.error('memory-bank.yaml errors:', result.errors);
+      }
+
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('context-config.yaml', () => {
+    const schema = loadYamlSchema(path.join(SCHEMAS_PATH, 'context-config.schema.yaml'));
+    const configPath = path.join(FLOWS_PATH, 'context-config.yaml');
+
+    it('should validate successfully', () => {
+      const result = validateYamlFile(configPath, schema);
+
+      if (!result.valid) {
+        console.error('context-config.yaml errors:', result.errors);
+      }
+
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('catalog.yaml', () => {
+    const schema = loadYamlSchema(path.join(SCHEMAS_PATH, 'catalog.schema.yaml'));
+    const configPath = path.join(FLOWS_PATH, 'templates/standards/catalog.yaml');
+
+    it('should validate successfully', () => {
+      const result = validateYamlFile(configPath, schema);
+
+      if (!result.valid) {
+        console.error('catalog.yaml errors:', result.errors);
+      }
+
+      expect(result.valid).toBe(true);
+    });
+  });
+});

package/src/iris_bundle/frameworks/iris-core/src/bin/cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const installer = require('../lib/installer');
+const packageJson = require('../package.json');
+
+program
+    .version(packageJson.version)
+    .description(packageJson.description);
+
+program
+    .command('install')
+    .description('Interactively install a irismd flow')
+    .action(installer.install);
+
+program
+    .command('uninstall')
+    .description('Uninstall irismd from the current project')
+    .action(installer.uninstall);
+
+program.parse(process.argv);