daedalion 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Daedalion Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# Daedalion
+
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm version](https://img.shields.io/npm/v/daedalion)](https://www.npmjs.com/package/daedalion)
+
+Spec-to-Agent compiler for GitHub Copilot. Write specs; get agents, skills, and prompts — all kept in sync with your source of truth.
+
+> *"Write specs, get agents automatically."*
+
+![daedalion-init](docs/assets/daedalion-init.png)
+
+## Overview
+
+Daedalion turns your `openspec/` specifications into native GitHub Copilot artifacts — agents, skills, prompts, and instructions. Your specs stay the source of truth; agents stay in sync automatically.
+
+```
+OpenSpec (what) ───▶ Daedalion ───▶ GitHub Copilot (how)
+```
+
+## Core Goal: Spec-Driven Development with AI
+
+**Daedalion's primary mission:** Ensure humans and AIs agree on **what to build** *before* any code is written.
+
+When you run `daedalion build`, it generates **`.github/prompts/daedalion-openspec-cycle.prompt.md`** — a guided workflow that:
+
+1. Routes AI to draft **proposals** (why, goals, scope) + **spec deltas** (what needs to change)
+2. Blocks coding until the **human explicitly approves specs**
+3. Guides implementation via a clear **task checklist**
+4. Archives completed changes and **merges specs into canonical truth**
+
+This prompt is your **AI code coordinator** — it prevents costly rework by enforcing spec clarity and human review at every phase.
+
+**The result:** Predictable, spec-aligned development where both humans and AIs follow the same playbook.
+
+## Why Daedalion + OpenSpec
+
+- Aligns humans and AIs on the “what” before any code.
+- Enforces approval gates with an AI coordinator prompt.
+- Generates native Copilot artifacts from `openspec/` automatically.
+- Prevents drift with `validate` and supports CI.
+
+## The Core Idea
+
+`daedalion build` generates `.github/prompts/daedalion-openspec-cycle.prompt.md` — your AI code coordinator that:
+- Routes work: proposal → review → implementation → archive
+- Blocks coding until specs are explicitly approved
+- Keeps tasks and deltas in lockstep with human review
+
+```mermaid
+flowchart LR
+  D[Draft: proposal + spec deltas] --> E{Approved?}
+  E -- no --> D
+  E -- yes --> F[Implement: tasks]
+  F --> G{All tasks complete?}
+  G -- no --> F
+  G -- yes --> H[Archive: merge into openspec/specs]
+```
+
+## Quick Start
+
+```bash
+npm install -g openspec daedalion
+openspec init          # creates openspec/ + AGENTS.md
+daedalion init         # adds daedalion.yaml + example specs
+daedalion build        # generates Copilot artifacts (agents, skills, prompts)
+daedalion validate     # checks specs ↔ artifacts are in sync
+```
+
+Use the coordinator by asking your AI: “Help me work through the OpenSpec cycle.”
+
+## What It Generates
+
+```
+.github/
+├── prompts/
+│   ├── daedalion-openspec-cycle.prompt.md  # AI coordinator (spec-driven workflow)
+│   └── {change}.prompt.md                  # Slash prompts for active changes
+├── agents/{domain}.agent.md                # Domain personas
+├── skills/{domain}/SKILL.md                # Auto-loaded skills from specs
+├── copilot-instructions.md                 # Project context from openspec/project.md
+└── workflows/daedalion.yml                 # Optional CI (validate / auto-regenerate)
+```
+
+## Commands
+
+- `daedalion init` - Scaffolds a new project with example specs:
+
+```
+project/
+├── daedalion.yaml
+└── openspec/
+    ├── project.md
+    ├── specs/
+    │   └── example/
+    │       └── spec.md
+    └── changes/
+        └── example-feature/
+            ├── proposal.md
+            └── tasks.md
+```
+
+- `daedalion build` - Generates GitHub Copilot artifacts from your specs:
+
+```
+.github/
+├── skills/
+│   └── {domain}/
+│       └── SKILL.md
+├── agents/
+│   └── {domain}.agent.md
+├── prompts/
+│   └── {change-name}.prompt.md
+├── workflows/
+│   └── daedalion.yml
+└── copilot-instructions.md
+```
+
+- `daedalion validate` — Verify specs and artifacts are in sync
+- `daedalion clean` — Remove only Daedalion-generated files
+
+
+## Learn More
+
+- OpenSpec format and conventions: [docs/openspec-format.md](docs/openspec-format.md)
+- Generated output details: [docs/generated-output.md](docs/generated-output.md)
+- CI setup and options: [docs/ci-workflow.md](docs/ci-workflow.md)
+- Developer notes: [docs/DEVELOPER.md](docs/DEVELOPER.md)
+
+## License
+
+MIT
+

package/bin/daedalion.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import { init } from '../src/commands/init.js';
+import { build } from '../src/commands/build.js';
+import { validate } from '../src/commands/validate.js';
+import { clean } from '../src/commands/clean.js';
+import { VERSION, getVersionString } from '../src/version.js';
+
+function displayLogo() {
+  const logo = `
+██████╗  █████╗ ███████╗██████╗  █████╗ ██╗     ██╗ ██████╗ ███╗   ██╗
+██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔══██╗██║     ██║██╔═══██╗████╗  ██║
+██║  ██║███████║█████╗  ██║  ██║███████║██║     ██║██║   ██║██╔██╗ ██║
+██║  ██║██╔══██║██╔══╝  ██║  ██║██╔══██║██║     ██║██║   ██║██║╚██╗██║
+██████╔╝██║  ██║███████╗██████╔╝██║  ██║███████╗██║╚██████╔╝██║ ╚████║
+╚═════╝ ╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝ ╚═════╝ ╚═╝  ╚═══╝
+`;
+
+  console.log(chalk.cyan(logo));
+  console.log(chalk.gray(`Author: Henry Bravo`));
+  console.log(chalk.gray(`Email: info@henrybravo.nl`));
+  console.log(chalk.gray(`Version: ${getVersionString()}`));
+  console.log();
+}
+
+// Display logo unless help is requested
+if (!process.argv.includes('--help') && !process.argv.includes('-h')) {
+  displayLogo();
+}
+
+program
+  .name('daedalion')
+  .description('OpenSpec-to-Agent compiler for GitHub Copilot')
+  .version(VERSION)
+  .helpOption('-h, --help', 'display help for command');
+
+program
+  .command('init')
+  .description('Scaffold config + example spec')
+  .option('--target <mode>', 'Agent target mode: ide or sdk')
+  .action(async (options) => {
+    try {
+      await init(process.cwd(), options);
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(2);
+    }
+  });
+
+program
+  .command('build')
+  .description('Generate .github/ from openspec/')
+  .option('--dry-run', 'Preview changes without writing files')
+  .option('--verbose', 'Detailed output for debugging')
+  .option('--force', 'Overwrite without confirmation')
+  .option('--with-tools', 'Generate tool stub files from specs')
+  .action(async (options) => {
+    try {
+      await build(process.cwd(), options);
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('validate')
+  .description('Check specs and generated output')
+  .action(async () => {
+    try {
+      const valid = await validate(process.cwd());
+      if (!valid) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('clean')
+  .description('Remove generated files')
+  .action(async () => {
+    try {
+      await clean(process.cwd());
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "daedalion",
+  "version": "0.0.1",
+  "description": "OpenSpec-to-Agent compiler for GitHub Copilot",
+  "bin": {
+    "daedalion": "./bin/daedalion.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "openspec",
+    "github-copilot",
+    "agents",
+    "skills",
+    "cli"
+  ],
+  "author": "Henry Bravo <info@henrybravo.nl>",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "glob": "^10.3.0",
+    "gray-matter": "^4.0.3",
+    "yaml": "^2.3.0"
+  },
+  "devDependencies": {
+    "vitest": "^1.0.0"
+  }
+}

package/src/commands/build.js

@@ -0,0 +1,198 @@
+import { existsSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { join, relative } 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';
+import { parseTasks } from '../parsers/tasks.js';
+import { generateSkill } from '../generators/skill.js';
+import { generateAgent } from '../generators/agent.js';
+import { generatePrompt, generateCyclePrompt } from '../generators/prompt.js';
+import { generateWorkflow } from '../generators/workflow.js';
+import { generateInstructions } from '../generators/instructions.js';
+import { generateTools } from '../generators/tools.js';
+import { ensureDir } from '../utils.js';
+
+const MANIFEST_FILENAME = '.daedalion-manifest.json';
+
+export async function build(cwd, options = {}) {
+  console.log();
+  console.log(chalk.bold(`  Daedalion v${VERSION}`));
+  console.log();
+
+  const config = loadConfig(cwd);
+  const openspecDir = resolveOpenspecPath(cwd, config);
+  const outputDir = resolveOutputPath(cwd, config);
+
+  if (!existsSync(openspecDir)) {
+    throw new Error(`OpenSpec directory not found: ${openspecDir}\n       Run 'daedalion init' first.`);
+  }
+
+  const generatedFiles = [];
+
+  // Parse specs
+  console.log('  Parsing specs...');
+  const specs = await findAndParseSpecs(openspecDir, options);
+  for (const spec of specs) {
+    console.log(chalk.gray(`    ✓ ${relative(cwd, spec.path)}`));
+  }
+
+  // Parse changes
+  console.log();
+  console.log('  Parsing changes...');
+  const changes = await findAndParseChanges(openspecDir, options);
+  for (const change of changes) {
+    console.log(chalk.gray(`    ✓ ${relative(cwd, change.proposal.path)}`));
+  }
+
+  // Aggregate tasks from all changes for skills
+  const allTasks = aggregateTasks(changes);
+
+  // Generate outputs
+  console.log();
+  console.log('  Generating...');
+
+  // Generate skills and agents from specs
+  for (const spec of specs) {
+    const tasks = allTasks[spec.domain] || null;
+    const skillResult = generateSkill(spec, tasks, outputDir, options);
+    generatedFiles.push(skillResult);
+    logGenerated(skillResult.path, cwd, options);
+
+    const agentResult = generateAgent(spec, outputDir, options, config);
+    generatedFiles.push(agentResult);
+    logGenerated(agentResult.path, cwd, options);
+  }
+
+  // Generate tool stubs if --with-tools flag is set
+  if (options.withTools) {
+    console.log(chalk.gray(`    (generating tool stubs)`));
+    for (const spec of specs) {
+      const toolResults = generateTools(spec, outputDir, config, options);
+      for (const toolResult of toolResults) {
+        generatedFiles.push(toolResult);
+        logGenerated(toolResult.path, cwd, options);
+      }
+    }
+  }
+
+  // Generate prompts from changes
+  for (const change of changes) {
+    const domain = findDomainForChange(change, specs);
+    const promptResult = generatePrompt(change.proposal, change.tasks, domain, outputDir, options);
+    generatedFiles.push(promptResult);
+    logGenerated(promptResult.path, cwd, options);
+  }
+
+  // Generate OpenSpec cycle prompt
+  const cyclePromptResult = generateCyclePrompt(outputDir, options);
+  generatedFiles.push(cyclePromptResult);
+  logGenerated(cyclePromptResult.path, cwd, options);
+
+  // Generate workflow
+  const workflowResult = generateWorkflow(config, outputDir, options);
+  generatedFiles.push(workflowResult);
+  logGenerated(workflowResult.path, cwd, options);
+
+  // Generate copilot-instructions.md
+  const instructionsResult = generateInstructions(openspecDir, outputDir, options);
+  generatedFiles.push(instructionsResult);
+  logGenerated(instructionsResult.path, cwd, options);
+
+  // Write manifest of generated files (for clean command)
+  if (!options.dryRun) {
+    writeManifest(outputDir, generatedFiles, cwd);
+  }
+
+  console.log();
+  if (options.dryRun) {
+    console.log(chalk.yellow(`  Dry run complete. ${generatedFiles.length} files would be generated.`));
+  } else {
+    console.log(chalk.green(`  Done. ${generatedFiles.length} files generated.`));
+  }
+  console.log();
+
+  return generatedFiles;
+}
+
+function writeManifest(outputDir, generatedFiles, cwd) {
+  const manifestPath = join(outputDir, MANIFEST_FILENAME);
+  const manifest = {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    files: generatedFiles.map(f => relative(cwd, f.path))
+  };
+  ensureDir(manifestPath);
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+
+async function findAndParseSpecs(openspecDir, options) {
+  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, options) {
+  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');
+    const tasksPath = join(changesDir, changeDir, 'tasks.md');
+
+    if (existsSync(proposalPath)) {
+      changes.push({
+        proposal: parseProposal(proposalPath),
+        tasks: parseTasks(tasksPath)
+      });
+    }
+  }
+
+  return changes;
+}
+
+function aggregateTasks(changes) {
+  const tasksByDomain = {};
+  for (const change of changes) {
+    // For now, associate all tasks with a generic key
+    // In a real implementation, you might parse domain from proposal
+    if (!tasksByDomain['default']) {
+      tasksByDomain['default'] = { groups: [], items: [], hasMore: false };
+    }
+    tasksByDomain['default'].items.push(...change.tasks.items);
+    tasksByDomain['default'].hasMore = tasksByDomain['default'].hasMore || change.tasks.hasMore;
+  }
+  return tasksByDomain;
+}
+
+function findDomainForChange(change, specs) {
+  // Try to match change to a spec domain
+  // For now, use the first spec's domain or 'default'
+  if (specs.length > 0) {
+    return specs[0].domain;
+  }
+  return 'default';
+}
+
+function logGenerated(filePath, cwd, options) {
+  const relativePath = relative(cwd, filePath);
+  if (options.dryRun) {
+    console.log(chalk.yellow(`    → ${relativePath}`));
+  } else {
+    console.log(chalk.green(`    ✓ ${relativePath}`));
+  }
+}

package/src/commands/clean.js

@@ -0,0 +1,85 @@
+import { existsSync, rmSync, readdirSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import chalk from 'chalk';
+import { VERSION } from '../version.js';
+import { loadConfig, resolveOutputPath } from '../config.js';
+
+const MANIFEST_FILENAME = '.daedalion-manifest.json';
+
+export async function clean(cwd) {
+  console.log();
+  console.log(chalk.bold(`  Daedalion v${VERSION} - Clean`));
+  console.log();
+
+  const config = loadConfig(cwd);
+  const outputDir = resolveOutputPath(cwd, config);
+
+  if (!existsSync(outputDir)) {
+    console.log(chalk.yellow('  No output directory found. Nothing to clean.'));
+    console.log();
+    return;
+  }
+
+  const manifestPath = join(outputDir, MANIFEST_FILENAME);
+
+  if (!existsSync(manifestPath)) {
+    console.log(chalk.yellow('  No manifest found. Run `daedalion build` first to generate a manifest.'));
+    console.log(chalk.gray('  (Clean requires a manifest to avoid deleting non-Daedalion files)'));
+    console.log();
+    return;
+  }
+
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const filesToRemove = manifest.files || [];
+
+  let removed = 0;
+  const cleanedDirs = new Set();
+
+  for (const relativePath of filesToRemove) {
+    const fullPath = join(cwd, relativePath);
+
+    if (existsSync(fullPath)) {
+      rmSync(fullPath, { force: true });
+      console.log(chalk.green(`  ✓ Removed ${relativePath}`));
+      removed++;
+
+      // Track parent directories for cleanup
+      cleanedDirs.add(dirname(fullPath));
+    }
+  }
+
+  // Remove the manifest itself
+  rmSync(manifestPath, { force: true });
+  console.log(chalk.green(`  ✓ Removed .github/${MANIFEST_FILENAME}`));
+
+  // Clean up empty directories (skills/domain/, agents/, etc.)
+  for (const dir of cleanedDirs) {
+    cleanEmptyDirs(dir, outputDir);
+  }
+
+  console.log();
+  if (removed > 0) {
+    console.log(chalk.green(`  Done. ${removed} files removed.`));
+  } else {
+    console.log(chalk.yellow('  No generated files found to clean.'));
+  }
+  console.log();
+}
+
+// Recursively remove empty directories up to (but not including) the output dir
+function cleanEmptyDirs(dir, stopAt) {
+  if (dir === stopAt || !existsSync(dir)) {
+    return;
+  }
+
+  try {
+    const contents = readdirSync(dir);
+    if (contents.length === 0) {
+      rmSync(dir, { recursive: true, force: true });
+      // Check parent directory too
+      cleanEmptyDirs(dirname(dir), stopAt);
+    }
+  } catch {
+    // Directory might have been removed already
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { VERSION } from '../version.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export async function init(cwd, options = {}) {
+  console.log();
+  console.log(chalk.bold(`  Daedalion v${VERSION}`));
+  console.log();
+
+  const templatesDir = join(__dirname, '../../templates/init');
+  const files = getAllFiles(templatesDir);
+  const { agentTarget } = options;
+
+  let created = 0;
+  let skipped = 0;
+
+  for (const file of files) {
+    const relativePath = relative(templatesDir, file);
+    const targetPath = join(cwd, relativePath);
+
+    if (existsSync(targetPath)) {
+      console.log(chalk.yellow(`  ⚠ ${relativePath} already exists, skipping`));
+      skipped++;
+      continue;
+    }
+
+    const dir = dirname(targetPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    copyFileSync(file, targetPath);
+    console.log(chalk.green(`  ✓ ${relativePath}`));
+    created++;
+  }
+
+  if (agentTarget === 'sdk') {
+    const configPath = join(cwd, 'daedalion.yaml');
+    if (existsSync(configPath)) {
+      let config = readFileSync(configPath, 'utf-8');
+      config = config.replace(/agents:\s*\n\s*target:\s*ide/, 'agents:\n  target: sdk');
+      writeFileSync(configPath, config);
+      console.log(chalk.cyan(`  ✓ Updated daedalion.yaml with SDK target`));
+    }
+  }
+
+  console.log();
+  if (created > 0) {
+    console.log(chalk.green(`  Done. ${created} files created.`));
+  }
+  if (skipped > 0) {
+    console.log(chalk.yellow(`  ${skipped} files skipped (already exist).`));
+  }
+
+  if (agentTarget === 'sdk') {
+    console.log();
+    console.log(chalk.cyan(`  Agent target set to SDK (for CI pipelines)`));
+    console.log(chalk.gray(`  Edit daedalion.yaml to add custom tool names under agents.tools`));
+  }
+
+  console.log();
+  console.log('  Next steps:');
+  console.log('    1. Edit openspec/specs/example/spec.md with your specifications');
+  console.log('    2. Run `daedalion build` to generate GitHub Copilot artifacts');
+  console.log();
+}
+
+function getAllFiles(dir, files = []) {
+  const entries = readdirSync(dir);
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      getAllFiles(fullPath, files);
+    } else {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}