@omnidev-ai/core 0.1.0

package/src/capability/rules.ts

@@ -0,0 +1,133 @@
+import { existsSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+import type { Doc, Rule } from "../types";
+
+/**
+ * Load rules from a capability's rules/ directory
+ * @param capabilityPath Path to the capability directory
+ * @param capabilityId ID of the capability
+ * @returns Array of Rule objects
+ */
+export async function loadRules(capabilityPath: string, capabilityId: string): Promise<Rule[]> {
+	const rulesDir = join(capabilityPath, "rules");
+
+	if (!existsSync(rulesDir)) {
+		return [];
+	}
+
+	const rules: Rule[] = [];
+	const entries = readdirSync(rulesDir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		if (entry.isFile() && entry.name.endsWith(".md")) {
+			const rulePath = join(rulesDir, entry.name);
+			const content = await Bun.file(rulePath).text();
+
+			rules.push({
+				name: basename(entry.name, ".md"),
+				content: content.trim(),
+				capabilityId,
+			});
+		}
+	}
+
+	return rules;
+}
+
+/**
+ * Write aggregated rules and docs to .omni/instructions.md
+ * Updates the generated section between markers while preserving user content
+ * @param rules Array of rules from all enabled capabilities
+ * @param docs Array of docs from all enabled capabilities
+ */
+export async function writeRules(rules: Rule[], docs: Doc[] = []): Promise<void> {
+	const instructionsPath = ".omni/instructions.md";
+
+	// Generate content from rules and docs
+	const rulesContent = generateRulesContent(rules, docs);
+
+	// Read existing content or create new file
+	let content: string;
+	if (existsSync(instructionsPath)) {
+		content = await Bun.file(instructionsPath).text();
+	} else {
+		// Create new file with basic template
+		content = `# OmniDev Instructions
+
+## Project Description
+<!-- TODO: Add 2-3 sentences describing your project -->
+[Describe what this project does and its main purpose]
+
+<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
+<!-- END OMNIDEV GENERATED CONTENT -->
+`;
+	}
+
+	// Replace content between markers
+	const beginMarker = "<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->";
+	const endMarker = "<!-- END OMNIDEV GENERATED CONTENT -->";
+
+	const beginIndex = content.indexOf(beginMarker);
+	const endIndex = content.indexOf(endMarker);
+
+	if (beginIndex === -1 || endIndex === -1) {
+		// Markers not found, append to end
+		content += `\n\n${beginMarker}\n${rulesContent}\n${endMarker}\n`;
+	} else {
+		// Replace content between markers
+		content =
+			content.substring(0, beginIndex + beginMarker.length) +
+			"\n" +
+			rulesContent +
+			"\n" +
+			content.substring(endIndex);
+	}
+
+	await Bun.write(instructionsPath, content);
+}
+
+function generateRulesContent(rules: Rule[], docs: Doc[] = []): string {
+	if (rules.length === 0 && docs.length === 0) {
+		return `<!-- This section is automatically updated when capabilities change -->
+
+## Capabilities
+
+No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.`;
+	}
+
+	let content = `<!-- This section is automatically updated when capabilities change -->
+
+## Capabilities
+
+`;
+
+	// Add documentation section if there are docs
+	if (docs.length > 0) {
+		content += `### Documentation
+
+`;
+		for (const doc of docs) {
+			content += `#### ${doc.name} (from ${doc.capabilityId})
+
+${doc.content}
+
+`;
+		}
+	}
+
+	// Add rules section if there are rules
+	if (rules.length > 0) {
+		content += `### Rules
+
+`;
+		for (const rule of rules) {
+			content += `#### ${rule.name} (from ${rule.capabilityId})
+
+${rule.content}
+
+`;
+		}
+	}
+
+	return content.trim();
+}

package/src/capability/skills.test.ts

@@ -0,0 +1,316 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadSkills } from "./skills";
+
+describe("loadSkills", () => {
+	const testDir = join(process.cwd(), "test-skills-temp");
+	const capabilityPath = join(testDir, "test-capability");
+
+	beforeEach(() => {
+		mkdirSync(capabilityPath, { recursive: true });
+	});
+
+	afterEach(() => {
+		if (testDir) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+	});
+
+	test("returns empty array when skills directory does not exist", async () => {
+		const skills = await loadSkills(capabilityPath, "test-cap");
+		expect(skills).toEqual([]);
+	});
+
+	test("returns empty array when skills directory is empty", async () => {
+		mkdirSync(join(capabilityPath, "skills"), { recursive: true });
+		const skills = await loadSkills(capabilityPath, "test-cap");
+		expect(skills).toEqual([]);
+	});
+
+	test("loads single skill with valid frontmatter and instructions", async () => {
+		const skillsDir = join(capabilityPath, "skills", "test-skill");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `---
+name: test-skill
+description: A test skill
+---
+
+# Instructions
+
+This is a test skill.`;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]).toEqual({
+			name: "test-skill",
+			description: "A test skill",
+			instructions: "# Instructions\n\nThis is a test skill.",
+			capabilityId: "test-cap",
+		});
+	});
+
+	test("loads multiple skills from different directories", async () => {
+		const skill1Dir = join(capabilityPath, "skills", "skill-1");
+		const skill2Dir = join(capabilityPath, "skills", "skill-2");
+		mkdirSync(skill1Dir, { recursive: true });
+		mkdirSync(skill2Dir, { recursive: true });
+
+		writeFileSync(
+			join(skill1Dir, "SKILL.md"),
+			`---
+name: skill-1
+description: First skill
+---
+
+Instructions for skill 1.`,
+		);
+
+		writeFileSync(
+			join(skill2Dir, "SKILL.md"),
+			`---
+name: skill-2
+description: Second skill
+---
+
+Instructions for skill 2.`,
+		);
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(2);
+		expect(skills[0]?.name).toBe("skill-1");
+		expect(skills[1]?.name).toBe("skill-2");
+	});
+
+	test("skips skill directories without SKILL.md file", async () => {
+		const validSkillDir = join(capabilityPath, "skills", "valid-skill");
+		const invalidSkillDir = join(capabilityPath, "skills", "no-skill-file");
+		mkdirSync(validSkillDir, { recursive: true });
+		mkdirSync(invalidSkillDir, { recursive: true });
+
+		writeFileSync(
+			join(validSkillDir, "SKILL.md"),
+			`---
+name: valid-skill
+description: Valid skill
+---
+
+Valid instructions.`,
+		);
+
+		// No SKILL.md in invalidSkillDir
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]?.name).toBe("valid-skill");
+	});
+
+	test("handles YAML frontmatter with quoted values", async () => {
+		const skillsDir = join(capabilityPath, "skills", "quoted-skill");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `---
+name: "quoted-skill"
+description: "A skill with quoted values"
+---
+
+Instructions here.`;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]?.name).toBe("quoted-skill");
+		expect(skills[0]?.description).toBe("A skill with quoted values");
+	});
+
+	test("handles YAML frontmatter with colons in values", async () => {
+		const skillsDir = join(capabilityPath, "skills", "colon-skill");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `---
+name: colon-skill
+description: A skill with a colon: in the description
+---
+
+Instructions here.`;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]?.description).toBe("A skill with a colon: in the description");
+	});
+
+	test("trims whitespace from instructions", async () => {
+		const skillsDir = join(capabilityPath, "skills", "whitespace-skill");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `---
+name: whitespace-skill
+description: Test whitespace trimming
+---
+
+
+Instructions with leading/trailing whitespace.
+
+	`;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]?.instructions).toBe("Instructions with leading/trailing whitespace.");
+	});
+
+	test("throws error when SKILL.md has no frontmatter", async () => {
+		const skillsDir = join(capabilityPath, "skills", "no-frontmatter");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `# Just Instructions
+
+No frontmatter here.`;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		await expect(loadSkills(capabilityPath, "test-cap")).rejects.toThrow(
+			/Invalid SKILL\.md format.*missing YAML frontmatter/,
+		);
+	});
+
+	test("throws error when SKILL.md is missing name field", async () => {
+		const skillsDir = join(capabilityPath, "skills", "missing-name");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `---
+description: Missing name field
+---
+
+Instructions here.`;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		await expect(loadSkills(capabilityPath, "test-cap")).rejects.toThrow(
+			/name and description required/,
+		);
+	});
+
+	test("throws error when SKILL.md is missing description field", async () => {
+		const skillsDir = join(capabilityPath, "skills", "missing-description");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `---
+name: missing-description
+---
+
+Instructions here.`;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		await expect(loadSkills(capabilityPath, "test-cap")).rejects.toThrow(
+			/name and description required/,
+		);
+	});
+
+	test("handles empty instructions after frontmatter", async () => {
+		const skillsDir = join(capabilityPath, "skills", "empty-instructions");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `---
+name: empty-instructions
+description: Skill with no instructions
+---
+`;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]?.instructions).toBe("");
+	});
+
+	test("preserves markdown formatting in instructions", async () => {
+		const skillsDir = join(capabilityPath, "skills", "markdown-skill");
+		mkdirSync(skillsDir, { recursive: true });
+
+		const skillContent = `---
+name: markdown-skill
+description: Skill with markdown
+---
+
+# Header
+
+- List item 1
+- List item 2
+
+**Bold text** and *italic text*.
+
+\`\`\`typescript
+const code = "example";
+\`\`\``;
+
+		writeFileSync(join(skillsDir, "SKILL.md"), skillContent);
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]?.instructions).toContain("# Header");
+		expect(skills[0]?.instructions).toContain("- List item 1");
+		expect(skills[0]?.instructions).toContain("**Bold text**");
+		expect(skills[0]?.instructions).toContain("```typescript");
+	});
+
+	test("ignores non-directory entries in skills folder", async () => {
+		const skillsDir = join(capabilityPath, "skills");
+		const validSkillDir = join(skillsDir, "valid-skill");
+		mkdirSync(validSkillDir, { recursive: true });
+
+		writeFileSync(
+			join(validSkillDir, "SKILL.md"),
+			`---
+name: valid-skill
+description: Valid skill
+---
+
+Valid instructions.`,
+		);
+
+		// Create a file directly in skills/ directory (should be ignored)
+		writeFileSync(join(skillsDir, "README.md"), "This should be ignored");
+
+		const skills = await loadSkills(capabilityPath, "test-cap");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]?.name).toBe("valid-skill");
+	});
+
+	test("associates skills with correct capability ID", async () => {
+		const skillsDir = join(capabilityPath, "skills", "test-skill");
+		mkdirSync(skillsDir, { recursive: true });
+
+		writeFileSync(
+			join(skillsDir, "SKILL.md"),
+			`---
+name: test-skill
+description: Test skill
+---
+
+Instructions.`,
+		);
+
+		const skills = await loadSkills(capabilityPath, "my-capability");
+
+		expect(skills).toHaveLength(1);
+		expect(skills[0]?.capabilityId).toBe("my-capability");
+	});
+});

package/src/capability/skills.ts

@@ -0,0 +1,56 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import type { Skill } from "../types";
+import { parseFrontmatterWithMarkdown } from "./yaml-parser";
+
+interface SkillFrontmatter {
+	name: string;
+	description: string;
+}
+
+export async function loadSkills(capabilityPath: string, capabilityId: string): Promise<Skill[]> {
+	const skillsDir = join(capabilityPath, "skills");
+
+	if (!existsSync(skillsDir)) {
+		return [];
+	}
+
+	const skills: Skill[] = [];
+	const entries = readdirSync(skillsDir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			const skillPath = join(skillsDir, entry.name, "SKILL.md");
+			if (existsSync(skillPath)) {
+				const skill = await parseSkillFile(skillPath, capabilityId);
+				skills.push(skill);
+			}
+		}
+	}
+
+	return skills;
+}
+
+async function parseSkillFile(filePath: string, capabilityId: string): Promise<Skill> {
+	const content = await Bun.file(filePath).text();
+
+	const parsed = parseFrontmatterWithMarkdown<SkillFrontmatter>(content);
+
+	if (!parsed) {
+		throw new Error(`Invalid SKILL.md format at ${filePath}: missing YAML frontmatter`);
+	}
+
+	const frontmatter = parsed.frontmatter;
+	const instructions = parsed.markdown;
+
+	if (!frontmatter.name || !frontmatter.description) {
+		throw new Error(`Invalid SKILL.md at ${filePath}: name and description required`);
+	}
+
+	return {
+		name: frontmatter.name,
+		description: frontmatter.description,
+		instructions: instructions.trim(),
+		capabilityId,
+	};
+}