daedalion 0.0.2 → 0.1.0

package/src/commands/init.js

@@ -1,101 +0,0 @@
-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, withExample } = options;
-
-  let created = 0;
-  let skipped = 0;
-
-  for (const file of files) {
-    const relativePath = relative(templatesDir, file);
-    const targetPath = join(cwd, relativePath);
-
-    // Skip example files if --with-example not provided
-    if (!withExample && isExampleFile(relativePath)) {
-      continue;
-    }
-
-    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;
-}
-
-function isExampleFile(relativePath) {
-  // Example files are in specs/example/ or changes/example-feature/
-  return relativePath.includes('specs/example/') || 
-         relativePath.includes('specs\\example\\') ||
-         relativePath.includes('changes/example-feature/') ||
-         relativePath.includes('changes\\example-feature\\');
-}

package/src/commands/validate.js

@@ -1,141 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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/skill.js

@@ -1,108 +0,0 @@
-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 specFrontmatter = spec.frontmatter && typeof spec.frontmatter === 'object'
-    ? spec.frontmatter
-    : {};
-
-  // Build frontmatter, preserving spec frontmatter (including tools) while providing defaults
-  const frontmatter = {
-    name: specFrontmatter.name || spec.domain,
-    description: specFrontmatter.description || `${description}. Use when working on ${keywords}.`,
-    ...specFrontmatter  // Preserve all other frontmatter properties (tools, etc.)
-  };
-
-  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();
-}

package/src/generators/tools.js

@@ -1,183 +0,0 @@
-import { writeFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { ensureDir } from '../utils.js';
-
-export function generateTools(spec, outputDir, config = {}, options = {}) {
-  const tools = extractTools(spec);
-  const language = config.tools?.language || 'python';
-  const generated = [];
-
-  for (const tool of tools) {
-    const stubResult = generateToolStub(tool, spec, outputDir, language, options);
-    generated.push(stubResult);
-  }
-
-  return generated;
-}
-
-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 mapPythonType(type) {
-  const typeMap = {
-    'string': 'str',
-    'String': 'str',
-    'number': 'int | float',
-    'Number': 'int | float',
-    'object': 'dict',
-    'Object': 'dict',
-    'array': 'Array',
-    'Array': 'Array',
-    'boolean': 'bool',
-    'Boolean': 'bool'
-  };
-
-  if (typeof type !== 'string') {
-    return 'Any';
-  }
-
-  return typeMap[type] || type || 'Any';
-}
-
-function getAllRequirementIds(spec) {
-  return spec.requirements.map((req, i) => ({
-    id: `REQ-${String(i + 1).padStart(3, '0')}`,
-    name: req.name
-  }));
-}
-
-function filterRelevantRequirements(spec, tool) {
-  if (!tool.requirements || !Array.isArray(tool.requirements)) {
-    return getAllRequirementIds(spec).slice(0, 2);
-  }
-
-  const allReqs = getAllRequirementIds(spec);
-  const toolReqIds = tool.requirements.map(r => {
-    if (typeof r === 'string' && r.startsWith('REQ-')) {
-      return r;
-    }
-    const idx = parseInt(r) || 1;
-    return `REQ-${String(idx).padStart(3, '0')}`;
-  });
-
-  return allReqs.filter(req => toolReqIds.includes(req.id));
-}
-
-function generatePythonStub(tool, spec, filePath, options) {
-  const toolReqs = filterRelevantRequirements(spec, tool);
-  const toolReqIds = toolReqs.map(r => r.id);
-
-  let content = `"""
-${tool.description || tool.name}
-Requirements: ${toolReqIds.join(', ') || 'TODO'}
-"""
-
-`;
-
-  content += `def ${tool.name}(${generatePythonSignature(tool)}) -> ${mapPythonType(tool.outputs?.[0] || 'dict')}:\n`;
-  content += `    """
-    ${tool.description || 'TODO: Add description'}
-    \n`;
-
-  if (tool.inputs && tool.inputs.length > 0) {
-    content += `    Args:\n`;
-    for (const input of tool.inputs) {
-      content += `        ${input.name}: ${mapPythonType(input.type || 'Any')} - ${input.description || 'TODO'}\n`;
-    }
-  }
-
-  if (tool.outputs && tool.outputs.length > 0) {
-    content += `    \n    Returns:\n`;
-    content += `        ${mapPythonType(tool.outputs[0] || 'dict')}\n`;
-  }
-
-  if (toolReqIds.length > 0) {
-    content += `    \n    Spec References:\n`;
-    for (const ref of toolReqIds) {
-      content += `        - ${ref}\n`;
-    }
-  }
-
-  content += `    """\n`;
-  content += `    raise NotImplementedError("Implement ${tool.name} logic")\n`;
-
-  if (options.dryRun) {
-    return { path: filePath, content };
-  }
-
-  ensureDir(filePath);
-  writeFileSync(filePath, content, 'utf-8');
-  return { path: filePath, content };
-}
-
-function generateToolStub(tool, spec, outputDir, language, options) {
-  const toolsDir = join(outputDir, 'tools');
-  const ext = getLanguageExt(language);
-  const toolPath = join(toolsDir, `${tool.name.toLowerCase()}${ext}`);
-
-  if (language === 'python') {
-    return generatePythonStub(tool, spec, toolPath, options);
-  } else if (language === 'javascript') {
-    return generateJavaScriptStub(tool, spec, toolPath, options);
-  }
-}
-
-function generatePythonSignature(tool) {
-  if (!tool.inputs || tool.inputs.length === 0) {
-    return '';
-  }
-
-  return tool.inputs.map(input => `${input.name}: ${mapPythonType(input.type)}`).join(', ');
-}
-
-function generateJSSignature(tool) {
-  if (!tool.inputs || tool.inputs.length === 0) {
-    return '{}';
-  }
-
-  return `{ ${tool.inputs.map(input => `${input.name}`).join(', ')} }`;
-}
-
-function getLanguageExt(language) {
-  const exts = { python: '.py', javascript: '.js' };
-  return exts[language] || '.py';
-}
-
-function mapJSType(type) {
-  const typeMap = {
-    'string': 'string',
-    'String': 'string',
-    'number': 'number',
-    'Number': 'number',
-    'object': 'Object',
-    'Object': 'Object',
-    'array': 'Array',
-    'Array': 'Array',
-    'boolean': 'boolean',
-    'Boolean': 'boolean'
-  };
-
-  if (typeof type !== 'string') {
-    return 'any';
-  }
-
-  return typeMap[type] || type || 'any';
-}
-
-function camelCase(str) {
-  return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase());
-}