daedalion 0.0.1

package/src/commands/validate.js

@@ -0,0 +1,141 @@
+import { existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { VERSION } from '../version.js';
+import { glob } from 'glob';
+import { loadConfig, resolveOpenspecPath, resolveOutputPath } from '../config.js';
+import { parseSpec } from '../parsers/spec.js';
+import { parseProposal } from '../parsers/proposal.js';
+
+export async function validate(cwd) {
+  console.log();
+  console.log(chalk.bold(`  Daedalion v${VERSION} - Validate`));
+  console.log();
+
+  const config = loadConfig(cwd);
+  const openspecDir = resolveOpenspecPath(cwd, config);
+  const outputDir = resolveOutputPath(cwd, config);
+
+  const errors = [];
+
+  // Parse all specs
+  const specs = await findAndParseSpecs(openspecDir);
+  const changes = await findAndParseChanges(openspecDir);
+
+  // Rule 1: Every spec has ≥1 requirement
+  for (const spec of specs) {
+    if (spec.requirements.length === 0) {
+      errors.push({
+        rule: 'spec-has-requirements',
+        message: `Spec "${spec.path}" has no requirements.\n       Add at least one "### Requirement:" section.`
+      });
+    }
+  }
+
+  // Rule 2: Every requirement has ≥1 scenario
+  for (const spec of specs) {
+    for (const req of spec.requirements) {
+      if (req.scenarios.length === 0) {
+        errors.push({
+          rule: 'requirement-has-scenarios',
+          message: `Requirement "${req.name}" in ${spec.domain} lacks scenarios.\n       Add at least one "#### Scenario:" section.`
+        });
+      }
+    }
+  }
+
+  // Rule 3: Generated skill exists for each spec
+  for (const spec of specs) {
+    const skillPath = join(outputDir, 'skills', spec.domain, 'SKILL.md');
+    if (!existsSync(skillPath)) {
+      errors.push({
+        rule: 'skill-exists-for-spec',
+        message: `Missing skill for spec ${spec.domain}.\n       Run 'daedalion build' to generate.`
+      });
+    }
+  }
+
+  // Rule 4: Generated prompt exists for each active change
+  for (const change of changes) {
+    const promptPath = join(outputDir, 'prompts', `${change.changeName}.prompt.md`);
+    if (!existsSync(promptPath)) {
+      errors.push({
+        rule: 'prompt-exists-for-change',
+        message: `Missing prompt for change ${change.changeName}.\n       Run 'daedalion build' to generate.`
+      });
+    }
+  }
+
+  // Rule 5: No orphaned skills
+  const skillsDir = join(outputDir, 'skills');
+  if (existsSync(skillsDir)) {
+    const skillDirs = readdirSync(skillsDir).filter(name => {
+      const fullPath = join(skillsDir, name);
+      return statSync(fullPath).isDirectory();
+    });
+
+    for (const skillName of skillDirs) {
+      const hasSpec = specs.some(s => s.domain === skillName);
+      if (!hasSpec) {
+        errors.push({
+          rule: 'no-orphan-skills',
+          message: `Orphan skill: ${skillName} has no source spec.\n       Remove .github/skills/${skillName}/ or create openspec/specs/${skillName}/spec.md`
+        });
+      }
+    }
+  }
+
+  // Output results
+  if (errors.length === 0) {
+    console.log(chalk.green('  ✓ All validations passed'));
+    console.log();
+    return true;
+  }
+
+  console.log(chalk.red(`  ✗ ${errors.length} validation error(s) found:`));
+  console.log();
+
+  for (const error of errors) {
+    console.log(chalk.red(`  Error: ${error.message}`));
+    console.log();
+  }
+
+  return false;
+}
+
+async function findAndParseSpecs(openspecDir) {
+  const specsDir = join(openspecDir, 'specs');
+  if (!existsSync(specsDir)) {
+    return [];
+  }
+
+  const specFiles = await glob('*/spec.md', { cwd: specsDir });
+  return specFiles.map(file => parseSpec(join(specsDir, file)));
+}
+
+async function findAndParseChanges(openspecDir) {
+  const changesDir = join(openspecDir, 'changes');
+  if (!existsSync(changesDir)) {
+    return [];
+  }
+
+  const changes = [];
+  const changeDirs = readdirSync(changesDir).filter(name => {
+    const fullPath = join(changesDir, name);
+    return statSync(fullPath).isDirectory();
+  });
+
+  for (const changeDir of changeDirs) {
+    const proposalPath = join(changesDir, changeDir, 'proposal.md');
+
+    if (existsSync(proposalPath)) {
+      const proposal = parseProposal(proposalPath);
+      changes.push({
+        changeName: proposal.changeName,
+        path: proposalPath
+      });
+    }
+  }
+
+  return changes;
+}

package/src/config.js

@@ -0,0 +1,50 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import yaml from 'yaml';
+
+const DEFAULT_CONFIG = {
+  version: 1,
+  target: 'github',
+  openspec: './openspec',
+  output: './.github',
+  ci: {
+    auto_commit: false,
+    commit_message: 'chore: regenerate agents from specs'
+  },
+  agents: {
+    target: 'ide',  // 'ide' or 'sdk'
+    tools: null     // null to use IDE defaults, or array of custom tool names
+  }
+};
+
+export function loadConfig(cwd) {
+  const configPath = join(cwd, 'daedalion.yaml');
+
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+
+  const content = readFileSync(configPath, 'utf-8');
+  const userConfig = yaml.parse(content) || {};
+
+  return {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    ci: {
+      ...DEFAULT_CONFIG.ci,
+      ...(userConfig.ci || {})
+    },
+    agents: {
+      ...DEFAULT_CONFIG.agents,
+      ...(userConfig.agents || {})
+    }
+  };
+}
+
+export function resolveOpenspecPath(cwd, config) {
+  return join(cwd, config.openspec);
+}
+
+export function resolveOutputPath(cwd, config) {
+  return join(cwd, config.output);
+}

package/src/generators/agent.js

@@ -0,0 +1,121 @@
+import { ensureDir } from '../utils.js';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+
+export function generateAgent(spec, outputDir, options = {}, config = {}) {
+  const agentPath = join(outputDir, 'agents', `${spec.domain}.agent.md`);
+
+  const skillDescription = generateSkillDescription(spec);
+  const agentConfig = config.agents || {};
+  const target = agentConfig.target || 'ide';
+
+  let tools;
+  let workflow;
+
+  if (target === 'sdk') {
+    const specTools = extractTools(spec);
+    tools = specTools.length > 0 ? specTools.map(t => t.name) : (agentConfig.tools || []);
+    workflow = generateSDKWorkflow(spec, tools);
+  } else {
+    tools = ['edit', 'search', 'terminal'];
+    workflow = generateIDEWorkflow(spec);
+  }
+
+  const toolsYaml = tools.length > 0
+    ? `tools: [${tools.map(t => `'${t}'`).join(', ')}]`
+    : '';
+
+  const content = `---
+name: ${spec.domain}
+description: Implements ${spec.domain} features following specifications
+${toolsYaml}
+---
+# ${spec.domain} Agent
+
+${workflow}
+`;
+
+  if (options.dryRun) {
+    return { path: agentPath, content };
+  }
+
+  ensureDir(agentPath);
+  writeFileSync(agentPath, content);
+  return { path: agentPath, content };
+}
+
+function extractTools(spec) {
+  const tools = [];
+  const frontmatter = spec.frontmatter || {};
+
+  if (frontmatter.tools && Array.isArray(frontmatter.tools)) {
+    for (const tool of frontmatter.tools) {
+      if (typeof tool === 'string') {
+        tools.push({ name: tool });
+      } else if (tool.name) {
+        tools.push(tool);
+      }
+    }
+  }
+
+  return tools;
+}
+
+function generateIDEWorkflow(spec) {
+  const skillDescription = generateSkillDescription(spec);
+
+  return `You implement ${spec.domain} features following the specification.
+
+## Available Skills
+- **#${spec.domain}** — ${skillDescription}
+
+## Workflow
+1. Read the #${spec.domain} skill for requirements
+2. Implement following acceptance criteria
+3. Verify all scenarios pass
+`;
+}
+
+function generateSDKWorkflow(spec, tools) {
+  const skillDescription = generateSkillDescription(spec);
+
+  if (tools.length === 0) {
+    return `You implement ${spec.domain} features following the specification.
+
+## Available Skills
+- **#${spec.domain}** — ${skillDescription}
+
+## Workflow
+1. Read the #${spec.domain} skill for requirements
+2. Implement following acceptance criteria
+3. Verify all scenarios pass
+`;
+  }
+
+  return `You implement ${spec.domain} features following the specification.
+
+## Available Skills
+- **#${spec.domain}** — ${skillDescription}
+
+## Available Tools
+${tools.map(t => `- **${t}**` ).join('\n')}
+
+## Workflow
+1. Read the #${spec.domain} skill for requirements
+2. Use available tools to implement following acceptance criteria
+3. Verify all scenarios pass
+`;
+}
+
+function generateSkillDescription(spec) {
+  if (spec.requirements.length === 0) {
+    return `${spec.title} requirements and acceptance criteria`;
+  }
+
+  const reqNames = spec.requirements
+    .slice(0, 3)
+    .map(r => r.name.toLowerCase())
+    .join(', ');
+
+  return `${spec.title} - ${reqNames}`;
+}

package/src/generators/instructions.js

@@ -0,0 +1,65 @@
+import { readFileSync, existsSync } from 'fs';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { ensureDir } from '../utils.js';
+
+export function generateInstructions(openspecDir, outputDir, options = {}) {
+  const projectPath = join(openspecDir, 'project.md');
+  const instructionsPath = join(outputDir, 'copilot-instructions.md');
+
+  let content;
+
+  if (existsSync(projectPath)) {
+    const projectContent = readFileSync(projectPath, 'utf-8');
+    content = transformProjectToInstructions(projectContent);
+  } else {
+    content = generateDefaultInstructions();
+  }
+
+  if (options.dryRun) {
+    return { path: instructionsPath, content };
+  }
+
+  ensureDir(instructionsPath);
+  writeFileSync(instructionsPath, content);
+  return { path: instructionsPath, content };
+}
+
+function transformProjectToInstructions(projectContent) {
+  // Note: GitHub Copilot natively reads AGENTS.md files, so no reference needed here.
+  // See: https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions
+  const header = `# Copilot Instructions
+
+> Auto-generated by Daedalion from openspec/project.md
+> Do not edit directly - changes will be overwritten.
+
+`;
+
+  return header + projectContent;
+}
+
+function generateDefaultInstructions() {
+  // Note: GitHub Copilot natively reads AGENTS.md files, so no reference needed here.
+  // See: https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions
+  return `# Copilot Instructions
+
+> Auto-generated by Daedalion
+> Do not edit directly - changes will be overwritten.
+
+## Project Overview
+
+This project uses OpenSpec for specification-driven development.
+
+## Working with Specifications
+
+- Specs are in \`openspec/specs/\`
+- Active changes are in \`openspec/changes/\`
+- Use the available skills and agents for implementation guidance
+
+## Available Resources
+
+Check the \`.github/skills/\` directory for implementation guides.
+Check the \`.github/agents/\` directory for specialized agents.
+Check the \`.github/prompts/\` directory for slash commands.
+`;
+}

package/src/generators/prompt.js

@@ -0,0 +1,113 @@
+import { ensureDir } from '../utils.js';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+
+export function generatePrompt(proposal, tasks, domain, outputDir, options = {}) {
+  const promptPath = join(outputDir, 'prompts', `${proposal.changeName}.prompt.md`);
+
+  const content = `---
+description: ${proposal.title}
+agent: ${domain || 'default'}
+---
+Implement the ${proposal.changeName} change proposal.
+
+## Context
+${proposal.why || 'No context provided.'}
+
+## Scope
+${proposal.what || 'No scope defined.'}
+
+## Reference
+- Proposal: openspec/changes/${proposal.changeName}/proposal.md
+- Tasks: openspec/changes/${proposal.changeName}/tasks.md
+
+## Skills
+- #${domain || 'default'}
+${tasks && tasks.items.length > 0 ? `
+## Tasks
+${tasks.items.map(t => `- [ ] ${t}`).join('\n')}
+${tasks.hasMore ? `\n> See full list in tasks.md` : ''}` : ''}
+`;
+
+  if (options.dryRun) {
+    return { path: promptPath, content };
+  }
+
+  ensureDir(promptPath);
+  writeFileSync(promptPath, content);
+  return { path: promptPath, content };
+}
+
+export function generateCyclePrompt(outputDir, options = {}) {
+  const promptPath = join(outputDir, 'prompts', 'daedalion-openspec-cycle.prompt.md');
+  const content = `---
+description: OpenSpec cycle coordinator
+agent: default
+---
+You are the OpenSpec cycle coordinator. Route requests to the correct OpenSpec prompt based on the project phase.
+
+## Core Principle
+**NEVER start coding until the specs are clear, agreed upon, and explicitly approved by the human.**
+
+## Source of Truth
+- \`openspec/specs/\` = approved, canonical specifications (never edit directly)
+- \`openspec/changes/<change-id>/specs/\` = temporary delta specs (additions/modifications/removals) that merge to canonical specs after approval
+- \`openspec/AGENTS.md\` = tool-specific integration instructions
+- \`openspec/project.md\` = project conventions (tech stack, naming rules, patterns)
+
+## Helpful CLI Commands
+- Use \`openspec view\` to see the status of proposals, tasks, and specs.
+- Use \`openspec view <change-id>\` to inspect the proposal, tasks, and spec deltas.
+- Use \`openspec list --changes\` or \`openspec list --specs\` for detailed views
+- Use \`openspec --help\` to see all available commands.
+
+## Inputs
+- User request
+- Optional change-id
+- Spec approval status
+- Task completion status
+
+## Workflow Phases
+
+### Phase 1: Draft (Proposal + Spec Deltas)
+- Create \`proposal.md\` (why, goals, scope, non-goals, risks)
+- Create \`tasks.md\` (numbered checklist with \`- [ ]\` checkboxes)
+- Create spec deltas in \`specs/<module>/spec.md\` with sections:
+  - \`## ADDED Requirements\`
+  - \`## MODIFIED Requirements\`
+  - \`## REMOVED Requirements\`
+  - Each requirement uses SHALL/MUST language
+  - Each requirement includes \`#### Scenario:\` blocks with WHEN → THEN outcomes
+
+### Phase 2: Review & Refine
+- Iterate on proposal, tasks, and delta specs based on human feedback
+- **Do NOT proceed to code until human explicitly approves specs**
+
+### Phase 3: Implement
+- Follow \`tasks.md\` checklist step-by-step
+- Update tasks: change \`- [ ]\` to \`- [x]\` as you complete items
+- Refine delta specs if needed (keep accurate)
+- Human confirms when all tasks are complete
+
+### Phase 4: Archive
+- Merge approved deltas from \`openspec/changes/<id>/specs/\` into \`openspec/specs/\`
+- Move change folder to \`openspec/archive/\`
+- **Requires human confirmation** (CLI: \`openspec archive <change-id> --yes\`)
+
+## Rules
+1. If no change-id exists or the request is to start new work → run @openspec-proposal.prompt.md to create proposal, tasks, and spec deltas. Ask for approval before coding.
+2. If specs are approved and implementation is requested → run @openspec-apply.prompt.md.
+3. If all tasks are complete and the user confirms → run @openspec-archive.prompt.md.
+4. If asked for status → summarize proposal + specs + tasks progress. Recommend the next phase clearly.
+
+Always state the current phase (Draft/Review/Implement/Ready to Archive/Archived) and the next action.
+`;
+
+  if (options.dryRun) {
+    return { path: promptPath, content };
+  }
+
+  ensureDir(promptPath);
+  writeFileSync(promptPath, content);
+  return { path: promptPath, content };
+}

package/src/generators/skill.js

@@ -0,0 +1,105 @@
+import { ensureDir } from '../utils.js';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import YAML from 'yaml';
+
+export function generateSkill(spec, tasks, outputDir, options = {}) {
+  const skillDir = join(outputDir, 'skills', spec.domain);
+  const skillPath = join(skillDir, 'SKILL.md');
+
+  const description = generateDescription(spec);
+  const keywords = extractKeywords(spec);
+
+  const baseFrontmatter = {
+    name: spec.domain,
+    description: `${description}. Use when working on ${keywords}.`
+  };
+  const specFrontmatter = spec.frontmatter && typeof spec.frontmatter === 'object'
+    ? spec.frontmatter
+    : {};
+  const frontmatter = { ...baseFrontmatter, ...specFrontmatter };
+  const agentInstructions = typeof specFrontmatter.agent_instructions === 'string'
+    ? specFrontmatter.agent_instructions
+    : null;
+
+  const frontmatterYaml = YAML.stringify(frontmatter).trimEnd();
+
+  let content = `---
+${frontmatterYaml}
+---
+`;
+
+  if (agentInstructions && agentInstructions.trim()) {
+    content += `# Agent Instructions
+
+${agentInstructions.trimEnd()}
+
+`;
+  }
+
+  content += `# ${spec.title}
+
+## Requirements
+${spec.requirements.map(r => `- **${r.name}**: ${r.description}`).join('\n')}
+
+## Acceptance Criteria
+${generateAcceptanceCriteria(spec.requirements)}`;
+
+  if (tasks && tasks.items.length > 0) {
+    content += `
+
+## Active Tasks
+${tasks.items.map(t => `- ${t}`).join('\n')}
+${tasks.hasMore ? `\n> Full task list: openspec/changes/*/tasks.md` : ''}`;
+  }
+
+  content += '\n';
+
+  if (options.dryRun) {
+    return { path: skillPath, content };
+  }
+
+  ensureDir(skillPath);
+  writeFileSync(skillPath, content);
+  return { path: skillPath, content };
+}
+
+function generateDescription(spec) {
+  if (spec.requirements.length === 0) {
+    return spec.title;
+  }
+
+  const firstReq = spec.requirements[0];
+  const desc = firstReq.description || firstReq.name;
+  return desc.slice(0, 100).replace(/\.$/, '');
+}
+
+function extractKeywords(spec) {
+  const words = new Set();
+  words.add(spec.domain);
+
+  for (const req of spec.requirements) {
+    const nameWords = req.name.toLowerCase().split(/\s+/);
+    nameWords.forEach(w => {
+      if (w.length > 3) words.add(w);
+    });
+  }
+
+  return Array.from(words).slice(0, 5).join(', ');
+}
+
+function generateAcceptanceCriteria(requirements) {
+  const criteria = [];
+
+  for (const req of requirements) {
+    for (const scenario of req.scenarios) {
+      criteria.push(`### ${scenario.name}`);
+      for (const step of scenario.steps) {
+        criteria.push(`- ${step}`);
+      }
+      criteria.push('');
+    }
+  }
+
+  return criteria.join('\n').trim();
+}