oh-my-opencode-medium 0.8.2

package/src/skills/cartography/scripts/test_cartographer.py

@@ -0,0 +1,87 @@
+import unittest
+import os
+import shutil
+import json
+import tempfile
+import hashlib
+from pathlib import Path
+from cartographer import PatternMatcher, compute_file_hash, compute_folder_hash, select_files
+
+class TestCartographer(unittest.TestCase):
+    def test_pattern_matcher(self):
+        patterns = ["node_modules/", "dist/", "*.log", "src/**/*.ts"]
+        matcher = PatternMatcher(patterns)
+        
+        # Directory patterns
+        self.assertTrue(matcher.matches("node_modules/foo.js"))
+        self.assertTrue(matcher.matches("vendor/node_modules/bar.js"))
+        self.assertTrue(matcher.matches("dist/main.js"))
+        self.assertTrue(matcher.matches("src/dist/output.js"))
+        
+        # Glob patterns
+        self.assertTrue(matcher.matches("error.log"))
+        self.assertTrue(matcher.matches("logs/access.log"))
+        
+        # Recursive glob patterns
+        self.assertTrue(matcher.matches("src/index.ts"))
+        self.assertTrue(matcher.matches("src/utils/helper.ts"))
+        
+        # Non-matches
+        self.assertFalse(matcher.matches("README.md"))
+        self.assertFalse(matcher.matches("tests/test.py"))
+
+    def test_compute_file_hash(self):
+        # Use binary mode to avoid any newline translation issues
+        with tempfile.NamedTemporaryFile(mode='wb', delete=False) as f:
+            f.write(b"test content")
+            f_path = f.name
+        
+        try:
+            h1 = compute_file_hash(Path(f_path))
+            # md5 of b"test content" is 9473fdd0d880a43c21b7778d34872157
+            expected = hashlib.md5(b"test content").hexdigest()
+            self.assertEqual(h1, expected)
+            self.assertEqual(h1, "9473fdd0d880a43c21b7778d34872157")
+        finally:
+            if os.path.exists(f_path):
+                os.unlink(f_path)
+
+    def test_compute_folder_hash(self):
+        file_hashes = {
+            "src/a.ts": "hash-a",
+            "src/b.ts": "hash-b",
+            "tests/test.ts": "hash-test"
+        }
+        
+        h1 = compute_folder_hash("src", file_hashes)
+        h2 = compute_folder_hash("src", file_hashes)
+        self.assertEqual(h1, h2)
+        
+        file_hashes_alt = {
+            "src/a.ts": "hash-a-modified",
+            "src/b.ts": "hash-b"
+        }
+        h3 = compute_folder_hash("src", file_hashes_alt)
+        self.assertNotEqual(h1, h3)
+
+    def test_select_files(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            (root / "src").mkdir()
+            (root / "node_modules").mkdir()
+            (root / "src" / "index.ts").write_text("code")
+            (root / "src" / "index.test.ts").write_text("test")
+            (root / "node_modules" / "foo.js").write_text("dep")
+            (root / "package.json").write_text("{}")
+            
+            includes = ["src/**/*.ts", "package.json"]
+            excludes = ["**/*.test.ts", "node_modules/"]
+            exceptions = []
+            
+            selected = select_files(root, includes, excludes, exceptions, [])
+            
+            rel_selected = sorted([os.path.relpath(f, root) for f in selected])
+            self.assertEqual(rel_selected, ["package.json", "src/index.ts"])
+
+if __name__ == "__main__":
+    unittest.main()

package/src/skills/loader.test.ts

@@ -0,0 +1,452 @@
+import { afterEach, describe, expect, it } from 'bun:test';
+import {
+  chmod,
+  mkdir,
+  mkdtemp,
+  rm,
+  symlink,
+  writeFile,
+} from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { discoverAllSkills, loadSkillsFromDirectories } from './loader';
+
+const tempDirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    tempDirs.splice(0).map((dir) =>
+      rm(dir, {
+        recursive: true,
+        force: true,
+      }),
+    ),
+  );
+});
+
+describe('loadSkillsFromDirectories', () => {
+  it('loads flat markdown skills', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    await writeFile(
+      join(root, 'summarize.md'),
+      '---\ndescription: Summarize code\n---\nSummarize:\n$ARGUMENTS\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills.summarize?.description).toBe('Summarize code');
+    expect(skills.summarize?.template).toContain('Summarize:');
+    expect(skills.summarize?.template.match(/\$ARGUMENTS/g)?.length).toBe(1);
+  });
+
+  it('loads nested SKILL.md and prefers frontmatter name', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    const skillDir = join(root, 'repo-map');
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(
+      join(skillDir, 'SKILL.md'),
+      '---\nname: atlas\ndescription: Map repo\nagent: explorer\nsubtask: true\n---\nUse @docs/README.md when mapping.\nIgnore @param tokens.\n',
+    );
+    await mkdir(join(skillDir, 'docs'), { recursive: true });
+    await writeFile(join(skillDir, 'docs', 'README.md'), '# repo map\n');
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills.atlas).toBeDefined();
+    expect(skills.atlas?.agent).toBe('explorer');
+    expect(skills.atlas?.subtask).toBe(true);
+    expect(skills.atlas?.template).toContain('<skill-instruction>');
+    expect(skills.atlas?.template).toContain('Base directory for this skill:');
+    expect(skills.atlas?.template).toContain(`${skillDir}/docs/README.md`);
+    expect(skills.atlas?.template).toContain('Ignore @param tokens.');
+    expect(skills.atlas?.template).toContain('<user-request>');
+    expect(skills.atlas?.template).toContain('$ARGUMENTS');
+  });
+
+  it('does not append duplicate $ARGUMENTS blocks to wrapped skills', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    const skillDir = join(root, 'repo-map');
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(
+      join(skillDir, 'SKILL.md'),
+      '---\ndescription: Map repo\n---\nUse this skill with:\n<user-request>\n$ARGUMENTS\n</user-request>\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills['repo-map']?.template.match(/\$ARGUMENTS/g)?.length).toBe(1);
+    expect(skills['repo-map']?.template.match(/<user-request>/g)?.length).toBe(
+      1,
+    );
+  });
+
+  it('resolves root-level @path references relative to the skill directory', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    const skillDir = join(root, 'repo-map');
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(
+      join(skillDir, 'SKILL.md'),
+      '---\ndescription: Map repo\n---\nRead @README.md before editing.\nIgnore @param tokens.\n',
+    );
+    await writeFile(join(skillDir, 'README.md'), '# repo map\n');
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills['repo-map']?.template).toContain(`${skillDir}/README.md`);
+    expect(skills['repo-map']?.template).toContain('Ignore @param tokens.');
+  });
+
+  it('uses colon-delimited relative paths for nested wrapped skills', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    const skillDir = join(root, 'bundle', 'repo-map');
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(
+      join(skillDir, 'SKILL.md'),
+      '---\ndescription: Deep skill\n---\nDeep prompt\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills['bundle:repo-map']?.description).toBe('Deep skill');
+    expect(skills['bundle:repo-map']?.template).toContain('Deep prompt');
+  });
+
+  it('loads a skill from a symlinked skill directory', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    const targetRoot = await mkdtemp(join(tmpdir(), 'skill-loader-target-'));
+    tempDirs.push(root, targetRoot);
+    const skillDir = join(targetRoot, 'planning-with-files');
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(
+      join(skillDir, 'SKILL.md'),
+      '---\ndescription: Planning skill\n---\nPlan carefully\n',
+    );
+    await symlink(skillDir, join(root, 'planning-with-files'));
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills['planning-with-files']?.description).toBe('Planning skill');
+  });
+
+  it('keeps the relative path for nested skills under symlinked roots', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    const targetRoot = await mkdtemp(join(tmpdir(), 'skill-loader-target-'));
+    tempDirs.push(root, targetRoot);
+    const skillDir = join(targetRoot, 'superpowers', 'brainstorming');
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(
+      join(skillDir, 'SKILL.md'),
+      '---\ndescription: Brainstorm\n---\nBrainstorm carefully\n',
+    );
+    await symlink(join(targetRoot, 'superpowers'), join(root, 'superpowers'));
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills['superpowers:brainstorming']?.description).toBe('Brainstorm');
+  });
+
+  it('keeps the namespace for nested wrapped skills with frontmatter names', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    const skillDir = join(root, 'superpowers', 'brainstorming');
+    await mkdir(skillDir, { recursive: true });
+    await writeFile(
+      join(skillDir, 'SKILL.md'),
+      '---\nname: brainstorming\ndescription: Brainstorm\n---\nBrainstorm carefully\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills['superpowers:brainstorming']?.description).toBe('Brainstorm');
+    expect(skills.brainstorming).toBeUndefined();
+  });
+
+  it('avoids repeated traversal through cyclic symlink directories', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    await mkdir(join(root, 'dir'), { recursive: true });
+    await writeFile(join(root, 'dir', 'note.txt'), 'x');
+    await symlink(join(root, 'dir'), join(root, 'alias'));
+    await symlink(root, join(root, 'dir', 'back'));
+
+    await expect(
+      Promise.race([
+        loadSkillsFromDirectories([{ path: root, source: 'agents' }]),
+        new Promise<never>((_, reject) =>
+          setTimeout(
+            () => reject(new Error('timed out traversing symlinks')),
+            200,
+          ),
+        ),
+      ]),
+    ).resolves.toEqual({});
+  });
+
+  it('ignores non-skill markdown files', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    await mkdir(join(root, 'notes'), { recursive: true });
+    await writeFile(
+      join(root, 'SKILL.md'),
+      '---\ndescription: wrong\n---\nWrong\n',
+    );
+    await writeFile(join(root, 'notes', 'README.md'), '# docs\n');
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills.SKILL).toBeUndefined();
+    expect(skills.README).toBeUndefined();
+  });
+
+  it('loads only root-level flat markdown files', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    await mkdir(join(root, 'notes'), { recursive: true });
+    await writeFile(
+      join(root, 'summarize.md'),
+      '---\ndescription: root\n---\nRoot\n',
+    );
+    await writeFile(
+      join(root, 'notes', 'summarize.md'),
+      '---\ndescription: nested\n---\nNested\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills.summarize?.description).toBe('root');
+    expect(skills.summarize?.template).toContain('Root');
+  });
+
+  it('lets later directories override earlier directories', async () => {
+    const globalDir = await mkdtemp(join(tmpdir(), 'skill-loader-global-'));
+    const projectDir = await mkdtemp(join(tmpdir(), 'skill-loader-project-'));
+    tempDirs.push(globalDir, projectDir);
+
+    await writeFile(
+      join(globalDir, 'review.md'),
+      '---\ndescription: global\n---\nGlobal review\n',
+    );
+    await writeFile(
+      join(projectDir, 'review.md'),
+      '---\ndescription: project\n---\nProject review\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: globalDir, source: 'agents' },
+      { path: projectDir, source: 'agents' },
+    ]);
+
+    expect(skills.review?.description).toBe('project');
+    expect(skills.review?.template).toContain('Project review');
+  });
+
+  it('skips unreadable skill directories', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    await writeFile(
+      join(root, 'review.md'),
+      '---\ndescription: review\n---\nReview\n',
+    );
+
+    await chmod(root, 0o000);
+
+    try {
+      const skills = await loadSkillsFromDirectories([
+        { path: root, source: 'agents' },
+      ]);
+
+      expect(skills).toEqual({});
+    } finally {
+      await chmod(root, 0o755);
+    }
+  });
+
+  it('skips unreadable skill files', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    const skillPath = join(root, 'review.md');
+    await writeFile(skillPath, '---\ndescription: review\n---\nReview\n');
+
+    await chmod(skillPath, 0o000);
+
+    try {
+      const skills = await loadSkillsFromDirectories([
+        { path: root, source: 'agents' },
+      ]);
+
+      expect(skills).toEqual({});
+    } finally {
+      await chmod(skillPath, 0o644);
+    }
+  });
+
+  it('drops model from agents skills but keeps it for opencode skills', async () => {
+    const agentsDir = await mkdtemp(join(tmpdir(), 'skill-loader-agents-'));
+    const opencodeDir = await mkdtemp(join(tmpdir(), 'skill-loader-opencode-'));
+    tempDirs.push(agentsDir, opencodeDir);
+
+    await writeFile(
+      join(agentsDir, 'review.md'),
+      '---\ndescription: agents\nmodel: openai/gpt-5\n---\nAgents review\n',
+    );
+    await writeFile(
+      join(opencodeDir, 'review.md'),
+      '---\ndescription: opencode\nmodel: openai/gpt-5\n---\nOpencode review\n',
+    );
+
+    const agentsSkills = await loadSkillsFromDirectories([
+      { path: agentsDir, source: 'agents' },
+    ]);
+    const opencodeSkills = await loadSkillsFromDirectories([
+      { path: opencodeDir, source: 'opencode' },
+    ]);
+
+    expect(agentsSkills.review?.model).toBeUndefined();
+    expect(opencodeSkills.review?.model).toBe('openai/gpt-5');
+  });
+
+  it('skips skills with malformed frontmatter', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    await writeFile(
+      join(root, 'broken.md'),
+      '---\ndescription [oops\n---\nPrompt\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills).toEqual({});
+  });
+
+  it('loads skills with yaml comments and structured metadata', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    await writeFile(
+      join(root, 'review.md'),
+      '---\n# comment\ndescription: Review code\ntags:\n  - docs\nnotes: |\n  line 1\nagent: explorer\n---\nReview:\n$ARGUMENTS\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills.review?.description).toBe('Review code');
+    expect(skills.review?.agent).toBe('explorer');
+  });
+
+  it('parses subtask metadata when the scalar has an inline comment', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skill-loader-'));
+    tempDirs.push(root);
+    await writeFile(
+      join(root, 'atlas.md'),
+      '---\ndescription: Review code\nsubtask: true # keep boolean\n---\nReview\n',
+    );
+
+    const skills = await loadSkillsFromDirectories([
+      { path: root, source: 'agents' },
+    ]);
+
+    expect(skills.atlas?.subtask).toBe(true);
+  });
+});
+
+describe('discoverAllSkills', () => {
+  it('loads installed opencode skills instead of src/skills directly', async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), 'skill-loader-project-'));
+    const homeDir = await mkdtemp(join(tmpdir(), 'skill-loader-home-'));
+    tempDirs.push(projectDir, homeDir);
+
+    await mkdir(join(homeDir, '.config', 'opencode', 'skills', 'bundle'), {
+      recursive: true,
+    });
+    await writeFile(
+      join(homeDir, '.config', 'opencode', 'skills', 'bundle', 'SKILL.md'),
+      '---\ndescription: bundled\n---\nBundled skill\n',
+    );
+
+    const skills = await discoverAllSkills(projectDir, homeDir);
+
+    expect(skills.bundle?.description).toBe('bundled');
+  });
+
+  it('reuses discovered skills for the same project and home directories', async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), 'skill-loader-project-'));
+    const homeDir = await mkdtemp(join(tmpdir(), 'skill-loader-home-'));
+    tempDirs.push(projectDir, homeDir);
+
+    const skillPath = join(homeDir, '.config', 'opencode', 'skills', 'bundle');
+    await mkdir(skillPath, { recursive: true });
+    await writeFile(
+      join(skillPath, 'SKILL.md'),
+      '---\ndescription: bundled\n---\nBundled skill\n',
+    );
+
+    const firstSkills = await discoverAllSkills(projectDir, homeDir);
+
+    await writeFile(
+      join(skillPath, 'SKILL.md'),
+      '---\ndescription: changed\n---\nChanged skill\n',
+    );
+
+    const secondSkills = await discoverAllSkills(projectDir, homeDir);
+
+    expect(firstSkills.bundle?.description).toBe('bundled');
+    expect(secondSkills.bundle?.description).toBe('bundled');
+  });
+
+  it('loads opencode skills from XDG_CONFIG_HOME when set', async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), 'skill-loader-project-'));
+    const homeDir = await mkdtemp(join(tmpdir(), 'skill-loader-home-'));
+    const xdgConfigHome = await mkdtemp(join(tmpdir(), 'skill-loader-xdg-'));
+    tempDirs.push(projectDir, homeDir, xdgConfigHome);
+
+    await mkdir(join(xdgConfigHome, 'opencode', 'skills', 'bundle'), {
+      recursive: true,
+    });
+    await writeFile(
+      join(xdgConfigHome, 'opencode', 'skills', 'bundle', 'SKILL.md'),
+      '---\ndescription: xdg bundled\n---\nBundled skill\n',
+    );
+
+    const previousXdgConfigHome = process.env.XDG_CONFIG_HOME;
+    process.env.XDG_CONFIG_HOME = xdgConfigHome;
+
+    try {
+      const skills = await discoverAllSkills(projectDir, homeDir);
+      expect(skills.bundle?.description).toBe('xdg bundled');
+    } finally {
+      if (previousXdgConfigHome === undefined) {
+        delete process.env.XDG_CONFIG_HOME;
+      } else {
+        process.env.XDG_CONFIG_HOME = previousXdgConfigHome;
+      }
+    }
+  });
+});