daedalion 0.0.1

package/src/generators/tools.js

@@ -0,0 +1,183 @@
+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());
+}

package/src/generators/workflow.js

@@ -0,0 +1,65 @@
+import { ensureDir } from '../utils.js';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+
+export function generateWorkflow(config, outputDir, options = {}) {
+  const workflowPath = join(outputDir, 'workflows', 'daedalion.yml');
+
+  const content = config.ci?.auto_commit
+    ? generateAutoCommitWorkflow(config)
+    : generateValidateOnlyWorkflow(config);
+
+  if (options.dryRun) {
+    return { path: workflowPath, content };
+  }
+
+  ensureDir(workflowPath);
+  writeFileSync(workflowPath, content);
+  return { path: workflowPath, content };
+}
+
+function generateValidateOnlyWorkflow(config) {
+  return `name: Daedalion
+on:
+  push:
+    paths: ['openspec/**']
+  pull_request:
+    paths: ['openspec/**']
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm install -g daedalion
+      - run: daedalion build --dry-run
+      - run: daedalion validate
+`;
+}
+
+function generateAutoCommitWorkflow(config) {
+  const commitMessage = config.ci?.commit_message || 'chore: regenerate agents from specs';
+
+  return `name: Daedalion
+on:
+  push:
+    branches: [main]
+    paths: ['openspec/**']
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm install -g daedalion
+      - run: daedalion build
+      - run: daedalion validate
+      - uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: '${commitMessage}'
+`;
+}

package/src/index.js

@@ -0,0 +1,14 @@
+export { init } from './commands/init.js';
+export { build } from './commands/build.js';
+export { validate } from './commands/validate.js';
+export { clean } from './commands/clean.js';
+export { loadConfig } from './config.js';
+export { parseSpec } from './parsers/spec.js';
+export { parseProposal } from './parsers/proposal.js';
+export { parseTasks } from './parsers/tasks.js';
+export { generateSkill } from './generators/skill.js';
+export { generateAgent } from './generators/agent.js';
+export { generatePrompt } from './generators/prompt.js';
+export { generateWorkflow } from './generators/workflow.js';
+export { generateInstructions } from './generators/instructions.js';
+export { generateTools } from './generators/tools.js';

package/src/parsers/proposal.js

@@ -0,0 +1,52 @@
+import { readFileSync } from 'fs';
+import { basename, dirname } from 'path';
+import matter from 'gray-matter';
+
+export function parseProposal(proposalPath) {
+  const content = readFileSync(proposalPath, 'utf-8');
+  const { data: frontmatter, content: body } = matter(content);
+
+  const changeName = basename(dirname(proposalPath));
+  const title = extractTitle(body);
+  const why = extractSection(body, 'Why');
+  const what = extractSection(body, 'What');
+
+  return {
+    path: proposalPath,
+    changeName,
+    title,
+    frontmatter,
+    why,
+    what
+  };
+}
+
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : 'Untitled Proposal';
+}
+
+function extractSection(content, sectionName) {
+  const lines = content.split('\n');
+  let inSection = false;
+  let sectionContent = [];
+
+  for (const line of lines) {
+    // Match ## Why or ## What (case insensitive)
+    const sectionMatch = line.match(/^##\s+(.+)$/);
+    if (sectionMatch) {
+      if (sectionMatch[1].toLowerCase() === sectionName.toLowerCase()) {
+        inSection = true;
+        continue;
+      } else if (inSection) {
+        break;
+      }
+    }
+
+    if (inSection && line.trim()) {
+      sectionContent.push(line.trim());
+    }
+  }
+
+  return sectionContent.join('\n') || null;
+}

package/src/parsers/spec.js

@@ -0,0 +1,105 @@
+import { readFileSync } from 'fs';
+import { basename, dirname } from 'path';
+import matter from 'gray-matter';
+
+export function parseSpec(specPath) {
+  const content = readFileSync(specPath, 'utf-8');
+  const { data: frontmatter, content: body } = matter(content);
+
+  const domain = basename(dirname(specPath));
+  const title = extractTitle(body);
+  const requirements = extractRequirements(body);
+
+  return {
+    path: specPath,
+    domain,
+    title,
+    frontmatter,
+    requirements
+  };
+}
+
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : 'Untitled Specification';
+}
+
+function extractRequirements(content) {
+  const requirements = [];
+  const lines = content.split('\n');
+
+  let currentRequirement = null;
+  let currentScenario = null;
+  let inRequirementDescription = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Match ### Requirement: Name
+    const reqMatch = line.match(/^###\s+Requirement:\s*(.+)$/i);
+    if (reqMatch) {
+      if (currentRequirement) {
+        if (currentScenario) {
+          currentRequirement.scenarios.push(currentScenario);
+        }
+        requirements.push(currentRequirement);
+      }
+      currentRequirement = {
+        name: reqMatch[1].trim(),
+        description: '',
+        scenarios: []
+      };
+      currentScenario = null;
+      inRequirementDescription = true;
+      continue;
+    }
+
+    // Match #### Scenario: Name
+    const scenarioMatch = line.match(/^####\s+Scenario:\s*(.+)$/i);
+    if (scenarioMatch && currentRequirement) {
+      if (currentScenario) {
+        currentRequirement.scenarios.push(currentScenario);
+      }
+      currentScenario = {
+        name: scenarioMatch[1].trim(),
+        steps: []
+      };
+      inRequirementDescription = false;
+      continue;
+    }
+
+    // Stop description collection at any heading
+    if (line.match(/^#{1,4}\s+/)) {
+      inRequirementDescription = false;
+      continue;
+    }
+
+    // Collect requirement description
+    if (inRequirementDescription && currentRequirement && line.trim()) {
+      if (currentRequirement.description) {
+        currentRequirement.description += ' ' + line.trim();
+      } else {
+        currentRequirement.description = line.trim();
+      }
+      continue;
+    }
+
+    // Collect scenario steps (lines starting with -)
+    if (currentScenario && line.match(/^\s*-\s+/)) {
+      const step = line.replace(/^\s*-\s+/, '').trim();
+      if (step) {
+        currentScenario.steps.push(step);
+      }
+    }
+  }
+
+  // Push last requirement/scenario
+  if (currentRequirement) {
+    if (currentScenario) {
+      currentRequirement.scenarios.push(currentScenario);
+    }
+    requirements.push(currentRequirement);
+  }
+
+  return requirements;
+}

package/src/parsers/tasks.js

@@ -0,0 +1,46 @@
+import { readFileSync, existsSync } from 'fs';
+
+export function parseTasks(tasksPath, maxItems = 10) {
+  if (!existsSync(tasksPath)) {
+    return { groups: [], items: [], hasMore: false };
+  }
+
+  const content = readFileSync(tasksPath, 'utf-8');
+  return summarizeTasks(content, maxItems);
+}
+
+export function summarizeTasks(content, maxItems = 10) {
+  const lines = content.split('\n');
+  const groups = [];
+  const items = [];
+  let currentGroup = null;
+  let totalItems = 0;
+
+  for (const line of lines) {
+    // Match headings as groups
+    const headingMatch = line.match(/^(#{1,3})\s+(.+)$/);
+    if (headingMatch) {
+      currentGroup = headingMatch[2].trim();
+      if (!groups.includes(currentGroup)) {
+        groups.push(currentGroup);
+      }
+      continue;
+    }
+
+    // Match top-level task items (- [ ] or - [x] or just -)
+    const taskMatch = line.match(/^-\s+(\[[ x]\])?\s*(.+)$/);
+    if (taskMatch && !line.match(/^\s{2,}-/)) {
+      totalItems++;
+      if (items.length < maxItems) {
+        const taskText = taskMatch[2].trim();
+        items.push(taskText);
+      }
+    }
+  }
+
+  return {
+    groups,
+    items,
+    hasMore: totalItems > maxItems
+  };
+}

package/src/utils.js

@@ -0,0 +1,51 @@
+import { mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+
+export function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function extractFirstHeading(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+
+export function extractDescription(content) {
+  const lines = content.split('\n');
+  let inFrontmatter = false;
+  let description = [];
+
+  for (const line of lines) {
+    if (line.trim() === '---') {
+      if (inFrontmatter) {
+        inFrontmatter = false;
+        continue;
+      }
+      inFrontmatter = true;
+      continue;
+    }
+
+    if (inFrontmatter) continue;
+
+    if (line.startsWith('#')) continue;
+
+    if (line.trim() && !line.startsWith('##')) {
+      description.push(line.trim());
+      if (description.length >= 2) break;
+    }
+
+    if (line.startsWith('##')) break;
+  }
+
+  return description.join(' ').slice(0, 200) || null;
+}
+
+export function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}

package/src/version.js

@@ -0,0 +1,60 @@
+import { execSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Read version from package.json
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+export const VERSION = pkg.version;
+
+/**
+ * Get version string with commit hash for dev builds
+ * @returns {string} e.g., "0.0.1" or "0.0.1-dev+abc1234"
+ */
+export function getVersionString() {
+  const commitHash = getCommitHash();
+  if (commitHash && !isReleaseBuild()) {
+    return `${VERSION}-dev+${commitHash}`;
+  }
+  return VERSION;
+}
+
+/**
+ * Get short commit hash
+ * @returns {string|null}
+ */
+function getCommitHash() {
+  try {
+    return execSync('git rev-parse --short HEAD', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'ignore']
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if this is a release build (tagged or npm published)
+ * @returns {boolean}
+ */
+function isReleaseBuild() {
+  // Check if running from node_modules (npm installed)
+  if (__dirname.includes('node_modules')) {
+    return true;
+  }
+
+  // Check if current commit is tagged
+  try {
+    execSync('git describe --exact-match --tags HEAD', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'ignore']
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/templates/init/daedalion.yaml

@@ -0,0 +1,18 @@
+version: 1
+target: github
+openspec: ./openspec
+output: ./.github
+
+# Optional
+# project_name: my-project
+# constitution: ./CONSTITUTION.md
+
+# CI behavior
+ci:
+  auto_commit: false
+  commit_message: 'chore: regenerate agents from specs'
+
+# Agent output configuration
+agents:
+  target: ide  # 'ide' or 'sdk'
+  tools: null  # null to use IDE defaults, or array of custom tool names

package/templates/init/openspec/changes/example-feature/proposal.md

@@ -0,0 +1,13 @@
+# Add Personalized Dashboard
+
+## Why
+
+Users need a central place to view their activity and preferences. Currently, they must navigate through multiple pages to find relevant information.
+
+## What
+
+Create a personalized dashboard that displays:
+- Recent activity summary
+- Quick actions
+- User preferences
+- Notifications

package/templates/init/openspec/changes/example-feature/tasks.md

@@ -0,0 +1,19 @@
+# Tasks
+
+## Setup
+
+- [ ] Create dashboard component structure
+- [ ] Set up routing for /dashboard
+
+## Implementation
+
+- [ ] Add activity summary widget
+- [ ] Add quick actions panel
+- [ ] Add preferences section
+- [ ] Add notifications component
+
+## Testing
+
+- [ ] Write unit tests for dashboard components
+- [ ] Write integration tests for data fetching
+- [ ] Manual QA testing

package/templates/init/openspec/project.md

@@ -0,0 +1,15 @@
+# Project Overview
+
+This project uses OpenSpec for specification-driven development.
+
+## Goals
+
+- Define clear specifications before implementation
+- Use agents and skills to guide development
+- Maintain alignment between specs and code
+
+## Conventions
+
+- All specifications follow OpenSpec format
+- Changes go through proposal → review → implementation workflow
+- Generated artifacts are kept in sync via Daedalion

package/templates/init/openspec/specs/example/spec.md

@@ -0,0 +1,37 @@
+# Example Specification
+
+This is an example specification demonstrating the OpenSpec format.
+
+## Requirements
+
+### Requirement: User Greeting
+
+The system SHALL greet users by name when they log in.
+
+#### Scenario: Known user logs in
+
+- GIVEN a user with name "Alice" exists
+- WHEN Alice logs in
+- THEN the system displays "Welcome, Alice!"
+
+#### Scenario: Anonymous user
+
+- GIVEN a user is not logged in
+- WHEN they access the homepage
+- THEN the system displays "Welcome, Guest!"
+
+### Requirement: Session Management
+
+The system SHALL maintain user sessions for 24 hours.
+
+#### Scenario: Active session
+
+- GIVEN a user has an active session
+- WHEN they make a request within 24 hours
+- THEN the session remains valid
+
+#### Scenario: Expired session
+
+- GIVEN a user's session is older than 24 hours
+- WHEN they make a request
+- THEN they are redirected to login