mirror of
https://github.com/nexu-io/open-design.git
synced 2026-09-20 06:15:06 +08:00
Tom Huang
b5eb8c1647
* feat: general-purpose skills with @-mention composition and user import
Lift skills from "one mode-bound skill per project" to a generic capability
the user can compose per turn:
- Daemon: scan multiple skill roots (user-skills under runtime data, then
the bundled `skills/`); user-imported skills can shadow built-ins by id.
- New `POST /api/skills/import` and `DELETE /api/skills/:id` endpoints,
with CONFLICT/BAD_REQUEST/NOT_FOUND error codes and built-in delete
protection.
- ChatRequest gains `skillIds: string[]`; the chat run concatenates each
picked skill's body (and merges craftRequires) into the system prompt
for that turn only — the project's persistent `skillId` is untouched.
- Web composer: `@` popover now lists skills alongside project files;
picks render as removable chips above the textarea and ride along with
the request as `skillIds`.
- Settings → Library: import form (name/description/triggers/body),
per-card delete for user skills, "user" origin badge.
* chore(web): drop welcome pet teaser + add ds→prompt-template mapping util
- SettingsDialog: remove the inline pet adoption teaser from the welcome
panel so the first-run modal stays focused on configuration.
- New `inferPromptTemplateCategoriesForDs(ds)` helper that maps a design
system's authored metadata to prompt-template gallery categories.
Imported by the design-system gallery wiring on a sibling branch; no
callers in this branch yet.
* feat: split skills/design-templates and add finalize-design API
Phase 0 of the skills/design-templates refactor (specs/current/
skills-and-design-templates.md):
- Move ~104 rendering catalogue entries from skills/ to design-templates/
and keep skills/ for the small set of functional skills that *do work*
on user input (utilities, briefs, packagers).
- Add design-templates/AGENTS.md and skills/AGENTS.md describing the
contract, and a brand-agnostic craft/ surface for opt-in craft rules.
- Daemon: add DESIGN_TEMPLATES_DIR / USER_DESIGN_TEMPLATES_DIR roots and
an /api/design-templates surface mirroring /api/skills. Asset/example
routes still span both registries so existing srcdoc URLs keep
resolving across the rename.
- Web: split LibrarySection into SkillsSection + DesignSystemsSection,
rename the EntryView "Examples" tab to "Templates", and update locales
+ the New-project picker accordingly.
Adds the finalize-design endpoint:
- New apps/daemon/src/finalize-design.ts and packages/contracts/src/api/
finalize.ts — one-shot synthesis of a project's transcript + active
design system + current artifact into <projectDir>/DESIGN.md via the
Anthropic Messages API. Per-project .finalize.lock mirrors the
transcript-export hygiene from PR #493; provider credentials are not
persisted by the daemon.
Other supporting changes:
- README + AGENTS.md updates to document the new directory split and
craft/ surface, plus i18n strings across 13 locales.
- Test refactors and new coverage (finalize-design, runs, sidecar
server, plus refreshed daemon integration tests).
- .gitignore: scope the *.exe ignore to /OpenDesign.exe so legitimate
vendor binaries are no longer hidden.
* fix(merge): move clinical-case-report to design-templates/
Origin/main added the clinical-case-report skill under skills/ before
the skills/design-templates split landed. Its od.mode is prototype, so
per specs/current/skills-and-design-templates.md it is a design template
and belongs alongside the other rendering catalogue entries — not under
the slimmed-down functional skills/ root. Moving it keeps the EntryView
Templates tab consistent with origin/main's intent.
* feat(skills): curated design/creative catalogue + collapsible Settings rows
Seed ~100 curated design/creative skill stubs under skills/ sourced from
awesome-claude-skills (ComposioHQ) and awesome-agent-skills (VoltAgent).
Each stub carries an od.category tag so the new filter pill row in
Settings -> Skills can group them. The seed script
(scripts/seed-curated-design-skills.ts, pnpm seed:curated-design-skills)
is idempotent: it only creates folders that don't already exist, so
hand-edited stubs are never overwritten.
- Daemon: parse and surface od.category on SkillInfo with a strict slug
normaliser; mirror the field on SkillSummary in @open-design/contracts.
Category is purely a UI hint — system-prompt composition is unchanged.
- Web: rewrite SkillsSection from a left-list / right-detail grid into a
vertical stack of collapsible rows mirroring the External MCP panel
(header always visible with name + mode/source/category pills + per-row
enable toggle; SKILL.md preview, file tree and inline edit form expand
on demand). Add a Category filter row above the list. Reorder Settings
nav so Skills + External MCP sit above the Composio/MCP cluster. Update
composer placeholder/hint across 17 locales to advertise '@ files or
skills · / for commands'.
- Docs: extend skills/AGENTS.md with the curated catalogue rules
(idempotency, category vocabulary, no upstream vendoring).
Co-authored-by: Cursor <cursoragent@cursor.com>
* test(skills): teach localized-content + system-prompt tests about the skills/design-templates split
mrcfps blocking review on PR #955: the skills/design-templates split
(b5993385) moved ~110 SKILL.md entries out of `skills/` and into
`design-templates/`, but two repo-level tests still hard-coded the
single-root layout, so CI gates went red on the merged branch:
- `e2e/tests/localized-content.test.ts` only scanned `<repo>/skills`
while the locale `skillCopy` map keeps id-keyed entries spanning
both roots (ExamplesTab/Templates uses one lookup regardless of
origin). Teach the helper to read both `skills/` and
`design-templates/`, deduplicating ids so the union matches the
localized claim.
- `apps/daemon/tests/prompts/system.test.ts` read
`skills/live-artifact/SKILL.md`, which now lives under
`design-templates/live-artifact/`. Update the absolute path so
composeSystemPrompt's coverage of the live-artifact preamble is
exercised again.
Also enroll the curated design/creative catalogue (PR #955, ~91
stubs sourced from awesome-claude-skills / awesome-agent-skills) in
the DE / FR / RU `_SKILL_IDS_WITH_EN_FALLBACK` lists. The stubs are
English-only by design (frontmatter advertises an upstream URL); the
fallback list is exactly the place to acknowledge "we know this id
exists, English copy is fine here" so the localized-content coverage
gate passes without forcing a translation task per locale.
Co-authored-by: Cursor <cursoragent@cursor.com>
* fix(skills): always quote frontmatter name so importUserSkill round-trips numeric / boolean ids
mrcfps PR #955 review: `buildSkillMarkdown` emitted `name:
${escapeYamlString(name)}` without quotes, so YAML coerced names
like `123`, `true`, `false`, or `null` into non-string scalars on
re-parse. listSkills() then read `data.name` as a number/boolean
and the import flow's follow-up `findSkillById(skills, result.id)`
missed it, falling into `/api/skills/import`'s "imported skill
could not be re-read" 500 path for those ids.
Switch the emitter to a quoted scalar (`name: "..."`) — the
double-escape already in `escapeYamlString` makes the quoted form
safe — and add a round-trip test covering `123`, `true`, `false`,
`null`, and `0` to lock in the contract.
Co-authored-by: Cursor <cursoragent@cursor.com>
* fix(web): drop staged-skill chips when the matching @<id> token leaves the draft
mrcfps PR #955 review: `submit()` always forwarded every id in
`stagedSkills`, but that state was only mutated on picker click and
chip removal. Hand-deleting an `@<id>` token from the textarea left
the chip staged, so the request still carried `skillIds: [<id>]` and
the daemon composed a skill the prompt no longer referenced.
Sync the chips with the draft inside `handleChange()` by pruning
`stagedSkills` whenever the new value no longer contains the
`@<id>` token (using the same whitespace boundary as
`removeStagedSkill`'s strip regex). Comment explains why this
prune does not run for `staged` file attachments — users frequently
add files via the upload button without leaving an `@<path>` token,
so a symmetric prune there would erase legitimate uploads.
Co-authored-by: Cursor <cursoragent@cursor.com>
* fix(daemon): stage @-composed skills' side files alongside the active skill
codex PR #955 review: composing a per-turn `@`-picked skill into the
system prompt appended its body (with the `withSkillRootPreamble`
guidance pointing at relative paths under `<cwd>/.od-skills/<folder>/`)
but never staged the actual folder. `startChatRun` only copied
`activeSkillDir`, so when the project's primary skill was different
(or absent) the composed skill's references/, examples/, and scripts/
files lived only at their absolute repo path — agents that honour
the cwd-relative form (or that don't get `--add-dir`, e.g. Codex with
allowlisted gpt-image projects) couldn't reach them.
Thread the composed skills' dirs out of `composeDaemonSystemPrompt`
as `extraSkillDirs` and stage each one through the same
`stageActiveSkill` API used for the primary skill. Dedupe by folder
basename so a project whose primary skill is also `@`-composed isn't
copied twice. Each preamble already advertises its own folder, so the
prompt and the staged tree stay aligned without further changes.
Co-authored-by: Cursor <cursoragent@cursor.com>
* fix(web): respect the Library disable toggle in the project @-mention picker
codex PR #955 review: only `EntryView` received `enabledSkills`
(filtered against `config.disabledSkills`); active projects still
got `skills={skills}` raw, so a skill the user disabled in Settings
kept appearing in the project's `@`-mention popover and could ride
along to the daemon via `skillIds`. That broke the Library toggle
for any project opened on the post-split branch.
Compute a functional-skills-only enabled subset
(`enabledFunctionalSkills`) and pass it into `<ProjectView>` instead.
Templates stay separate — design-templates are filtered through their
own `enabledDesignTemplates` memo for the Templates gallery — so
ProjectView's chat composer still only sees skills, never templates,
matching the pre-split prop surface.
Co-authored-by: Cursor <cursoragent@cursor.com>
* test(e2e): mock /api/design-templates for example-use-prompt flow
The Templates tab in EntryView fetches from /api/design-templates after
the skills/design-templates split (specs/current/skills-and-design-templates.md).
The example-use-prompt Playwright scenario only mocked /api/skills, so the
gallery card never appeared and the test timed out waiting on
example-card-warm-utility-example. Serve the same fixture summary on both
endpoints so the templates gallery renders the card the test clicks.
Co-authored-by: Cursor <cursoragent@cursor.com>
* test(tools-pack): create design-templates fixture for resources test
The packaging resources copy now bundles the new design-templates tree
alongside skills (see resources.ts BUNDLED_RESOURCE_TREES). The
copyBundledResourceTrees fixture only created skills, design-systems,
craft, etc., so the recursive copy crashed with ENOENT on
design-templates before it could check the prompt-templates assertion.
Add the missing fixture directory so the test exercises the same set
of resource trees the packaged build does.
Co-authored-by: Cursor <cursoragent@cursor.com>
* fix(skills): clone built-in side files into the shadow on first edit
mrcfps PR #955 review: editing a built-in skill wrote a USER_SKILLS_DIR
shadow folder that contained only a new SKILL.md. The next listSkills()
pass surfaced the shadow as the active dir, but every side-file resolver
(/api/skills/:id/files, /example, /assets/*, the system-prompt preamble,
and the per-turn cwd staging) reads through skill.dir. With nothing but
SKILL.md in the shadow, the bundled assets/, references/, scripts/, and
examples/ disappeared the moment the user hit save — a built-in like
last30days or live-artifact would break immediately after edit instead
of just having its body overridden.
Teach updateUserSkill() to take a `sourceDir` and clone every entry
except SKILL.md / dotfiles into the shadow on the very first edit. The
shadow stays self-contained, so all the resolvers keep working without
fallback bookkeeping. Subsequent edits detect the existing shadow and
skip the clone, so user tweaks under the side tree survive a re-save.
Wire `sourceDir: skill.dir` from server.ts's PUT /api/skills/:id handler
and add two regression tests:
- 'clones built-in side files into the shadow on the first edit' walks
the file tree after save and asserts assets/template.html, references/
notes.md, and scripts/helper.sh all round-trip from the built-in.
- 'preserves user-edited side files on subsequent edits' edits the
staged assets/template.html, re-saves, and confirms the user content
is still there.
Co-authored-by: Cursor <cursoragent@cursor.com>
* test(e2e): rename home tab from Examples to Templates
The Examples tab was renamed to Templates in EntryView (b5993385's
skills/design-templates split — entry.tabExamples became entry.tabTemplates
and the tab value moved from 'examples' to 'templates'), but
entry-chrome-flows still asserted the old label and testId. Update both.
* fix(skills+web): preserve template body in API mode and dir-based skill delete
Two follow-ups from PR #955 review:
1. ProjectView only received `enabledFunctionalSkills`, but
`composedSystemPrompt()` still resolved `project.skillId` through that
prop and `fetchSkill()`. Projects created from the new
`/api/design-templates` surface keep a template id in `project.skillId`,
so opening one in API mode dropped the template body from the system
prompt and the upstream request ran without the project's primary
template instructions. Now ProjectView takes a separate
`designTemplates` prop (the unfiltered template list, so a
later-disabled template still loads for projects already created from
it) and `composedSystemPrompt()` plus the metadata / `isDeck` lookups
fall back to that list, with `fetchDesignTemplate()` as the body-fetch
fallback to `fetchSkill()`. The chat composer's `@`-picker keeps
receiving only the enabled functional skills.
2. `DELETE /api/skills/:id` used `deleteUserSkill(USER_SKILLS_DIR, skill.id)`
which re-slugified the frontmatter id and removed
`<userSkillsDir>/<slug>/`. That matched the import shape but missed the
install shape — `installFromTarget` writes the folder at
`sanitizeRepoName(url)` (GitHub) or `path.basename(realpath)` (local
symlink), neither of which is guaranteed to equal the slugified
frontmatter `name`. A duplicate `app.delete('/api/skills/:id', ...)`
handler at the install routes never fired because Express resolved the
earlier registration first, leaving the install/uninstall path without
working teardown. The handler now removes `skill.dir` (the absolute
path listSkills already discovered) under a USER_SKILLS_DIR safety
check, using `lstat` + `unlinkSync` so symlinked local installs unlink
cleanly without recursing into the user's source tree. The dead
duplicate handler is removed; `deleteUserSkill` is dropped from the
server.ts import set (still exported and unit-tested in skills.ts).
Regression coverage in `apps/daemon/tests/skills-delete-route.test.ts`
pins both shapes plus the symlink-preserves-source case.
* test(daemon): point hyperframes system-prompt test at design-templates
The merge with main brought in a hyperframes system-prompt test that
reads `skills/hyperframes/SKILL.md`, but this branch's split moved
`hyperframes` into `design-templates/` (same migration as `live-artifact`
already handled above in this file). CI was failing with ENOENT on the
old path.
---------
Co-authored-by: Cursor <cursoragent@cursor.com>
596 lines
22 KiB
TypeScript
596 lines
22 KiB
TypeScript
import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { fileURLToPath } from 'node:url';
|
|
import path from 'node:path';
|
|
|
|
import { describe, expect, it } from 'vitest';
|
|
|
|
import { rmSync } from 'node:fs';
|
|
|
|
import { SKILLS_CWD_ALIAS } from '../src/cwd-aliases.js';
|
|
import { readFileSync } from 'node:fs';
|
|
import {
|
|
deleteUserSkill,
|
|
importUserSkill,
|
|
listSkillFiles,
|
|
listSkills,
|
|
slugifySkillName,
|
|
updateUserSkill,
|
|
} from '../src/skills.js';
|
|
|
|
const __filename = fileURLToPath(import.meta.url);
|
|
const __dirname = path.dirname(__filename);
|
|
const repoRoot = path.resolve(__dirname, '../../..');
|
|
const skillsRoot = path.join(repoRoot, 'skills');
|
|
// `live-artifact`, `dcf-valuation`, `x-research`, and `last30days` were
|
|
// reclassified as design templates under the Phase 0 split (see
|
|
// specs/current/skills-and-design-templates.md). The body/preamble
|
|
// expectations below still apply, but they now read from the design
|
|
// templates root rather than skills/.
|
|
const designTemplatesRoot = path.join(repoRoot, 'design-templates');
|
|
const liveArtifactRoot = path.join(designTemplatesRoot, 'live-artifact');
|
|
|
|
type SkillCatalogEntry = {
|
|
id: string;
|
|
name: string;
|
|
mode: string;
|
|
previewType: string;
|
|
triggers: string[];
|
|
body: string;
|
|
};
|
|
|
|
function fresh(): string {
|
|
return mkdtempSync(path.join(tmpdir(), 'od-skills-'));
|
|
}
|
|
|
|
function writeSkill(
|
|
root: string,
|
|
folder: string,
|
|
options: {
|
|
name?: string;
|
|
description?: string;
|
|
body?: string;
|
|
withAttachments?: boolean;
|
|
} = {},
|
|
) {
|
|
const dir = path.join(root, folder);
|
|
mkdirSync(dir, { recursive: true });
|
|
const fm = [
|
|
'---',
|
|
`name: ${options.name ?? folder}`,
|
|
`description: ${options.description ?? 'A test skill.'}`,
|
|
'---',
|
|
'',
|
|
options.body ?? '# Test skill body',
|
|
'',
|
|
].join('\n');
|
|
writeFileSync(path.join(dir, 'SKILL.md'), fm);
|
|
if (options.withAttachments) {
|
|
mkdirSync(path.join(dir, 'assets'), { recursive: true });
|
|
writeFileSync(
|
|
path.join(dir, 'assets', 'template.html'),
|
|
'<html><body>seed</body></html>',
|
|
);
|
|
}
|
|
}
|
|
|
|
describe('listSkills', () => {
|
|
it('includes the built-in live-artifact skill catalog entry', async () => {
|
|
const skills = await listSkills(designTemplatesRoot);
|
|
const skill = skills.find((entry: { id: string }) => entry.id === 'live-artifact');
|
|
|
|
if (!skill) throw new Error('live-artifact skill not found');
|
|
expect(skill).toMatchObject({
|
|
id: 'live-artifact',
|
|
name: 'live-artifact',
|
|
mode: 'prototype',
|
|
previewType: 'html',
|
|
});
|
|
expect(skill.triggers.length).toBeGreaterThan(0);
|
|
expect(skill.body).toContain(`> **Skill root (absolute fallback):** \`${liveArtifactRoot}\``);
|
|
expect(skill.body).toContain(`${SKILLS_CWD_ALIAS}/live-artifact/`);
|
|
expect(skill.body).toContain('references/artifact-schema.md');
|
|
expect(skill.body).toContain('references/connector-policy.md');
|
|
expect(skill.body).toContain('references/refresh-contract.md');
|
|
expect(skill.body).toContain(`${SKILLS_CWD_ALIAS}/live-artifact/references/artifact-schema.md`);
|
|
expect(skill.body).not.toContain(`${SKILLS_CWD_ALIAS}/live-artifact/assets/template.html`);
|
|
expect(skill.body).not.toContain(`${SKILLS_CWD_ALIAS}/live-artifact/references/layouts.md`);
|
|
expect(skill.body).toContain('"$OD_NODE_BIN" "$OD_BIN" tools live-artifacts create --input artifact.json');
|
|
expect(skill.body).toContain('do not ask “where should the data come from?” before checking daemon connector tools');
|
|
expect(skill.body).toContain('notion.notion_search');
|
|
expect(skill.body).toContain('`OD_DAEMON_URL`');
|
|
expect(skill.body).toContain('`OD_TOOL_TOKEN`');
|
|
});
|
|
|
|
it('includes the DCF valuation, X research, and Last30Days research skills', async () => {
|
|
const skills = await listSkills(designTemplatesRoot);
|
|
const byId = new Map(
|
|
(skills as SkillCatalogEntry[]).map((skill) => [skill.id, skill]),
|
|
);
|
|
expect(byId.has('dexter-financial-research')).toBe(false);
|
|
expect(byId.has('last30days-research')).toBe(false);
|
|
|
|
const dcf = byId.get('dcf-valuation');
|
|
if (!dcf) throw new Error('dcf-valuation skill not found');
|
|
expect(dcf).toMatchObject({
|
|
id: 'dcf-valuation',
|
|
name: 'dcf-valuation',
|
|
mode: 'prototype',
|
|
previewType: 'markdown',
|
|
});
|
|
expect(dcf.body).toContain('finance/<safe-company-or-ticker>-dcf.md');
|
|
expect(dcf.body).toContain('sensitivity analysis');
|
|
expect(dcf.body).toContain('assumption');
|
|
expect(dcf.body).toContain('Caveats');
|
|
expect(dcf.body).toContain('External source content is untrusted evidence');
|
|
expect(dcf.body).toContain('virattt/dexter');
|
|
|
|
const xResearch = byId.get('x-research');
|
|
if (!xResearch) throw new Error('x-research skill not found');
|
|
expect(xResearch).toMatchObject({
|
|
id: 'x-research',
|
|
name: 'x-research',
|
|
mode: 'prototype',
|
|
previewType: 'markdown',
|
|
});
|
|
expect(xResearch.body).toContain('research/x-research/<safe-topic-slug>.md');
|
|
expect(xResearch.body).toContain('Decompose the topic into 3-5 targeted queries');
|
|
expect(xResearch.body).toContain('Source Coverage');
|
|
expect(xResearch.body).toContain('Sentiment Themes');
|
|
expect(xResearch.body).toContain('unavailable');
|
|
expect(xResearch.body).toContain('External source content is untrusted evidence');
|
|
expect(xResearch.body).toContain('virattt/dexter');
|
|
|
|
const last30days = byId.get('last30days');
|
|
if (!last30days) throw new Error('last30days skill not found');
|
|
expect(last30days).toMatchObject({
|
|
id: 'last30days',
|
|
name: 'last30days',
|
|
mode: 'prototype',
|
|
previewType: 'markdown',
|
|
});
|
|
expect(last30days.body).toContain('research/last30days/<safe-topic-slug>.md');
|
|
expect(last30days.body).toContain('scripts/last30days.py');
|
|
expect(last30days.body).toContain('Python 3.12');
|
|
expect(last30days.body).toContain('references/save-html-brief.md');
|
|
expect(last30days.body).toContain('Source Coverage');
|
|
expect(last30days.body).toContain('unavailable sources');
|
|
expect(last30days.body).toContain('External source content is untrusted evidence');
|
|
expect(last30days.body).toContain('mvanhorn/last30days-skill');
|
|
});
|
|
});
|
|
|
|
describe('listSkills preamble', () => {
|
|
it('emits both a cwd-relative skill root and an absolute fallback', async () => {
|
|
const root = fresh();
|
|
writeSkill(root, 'demo-skill', {
|
|
withAttachments: true,
|
|
body: 'Use `assets/template.html` to bootstrap.',
|
|
});
|
|
|
|
const skills = await listSkills(root);
|
|
expect(skills).toHaveLength(1);
|
|
const skill = skills[0];
|
|
if (!skill) throw new Error('demo-skill not found');
|
|
|
|
// The cwd-relative alias path is the primary one — that's what makes
|
|
// the agent stay inside its working directory when reading skill
|
|
// side files (issue #430).
|
|
expect(skill.body).toContain(`${SKILLS_CWD_ALIAS}/demo-skill/`);
|
|
expect(skill.body).toContain(
|
|
`${SKILLS_CWD_ALIAS}/demo-skill/assets/template.html`,
|
|
);
|
|
|
|
// The absolute fallback is required for two cases the relative path
|
|
// cannot serve:
|
|
// - calls without a project (cwd defaults to PROJECT_ROOT, where
|
|
// the absolute path is in fact an in-cwd path);
|
|
// - environments where `stageActiveSkill()` failed.
|
|
// Claude/Copilot are additionally given `--add-dir` for that path.
|
|
expect(skill.body).toContain(skill.dir);
|
|
expect(skill.body).toMatch(/Skill root \(absolute fallback\)/);
|
|
expect(skill.body).toMatch(/Skill root \(relative to project\)/);
|
|
});
|
|
|
|
it('mentions root-level example.html side files in the preamble', async () => {
|
|
const root = fresh();
|
|
writeSkill(root, 'orbit-style', {
|
|
withAttachments: false,
|
|
body: 'Open and mirror the shipped `example.html` before writing output.',
|
|
});
|
|
writeFileSync(path.join(root, 'orbit-style', 'example.html'), '<main>example</main>');
|
|
|
|
const skills = await listSkills(root);
|
|
expect(skills).toHaveLength(1);
|
|
const skill = skills[0];
|
|
if (!skill) throw new Error('orbit-style skill not found');
|
|
|
|
expect(skill.body).toContain(`${SKILLS_CWD_ALIAS}/orbit-style/`);
|
|
expect(skill.body).toContain(`${SKILLS_CWD_ALIAS}/orbit-style/example.html`);
|
|
expect(skill.body).toContain('Known side files in this skill: `example.html`.');
|
|
});
|
|
|
|
it('uses the on-disk folder name in the alias path even when `name` differs', async () => {
|
|
const root = fresh();
|
|
writeSkill(root, 'guizang-ppt', {
|
|
name: 'magazine-web-ppt',
|
|
withAttachments: true,
|
|
});
|
|
|
|
const skills = await listSkills(root);
|
|
expect(skills).toHaveLength(1);
|
|
const skill = skills[0];
|
|
if (!skill) throw new Error('magazine-web-ppt skill not found');
|
|
|
|
// `id`/`name` reflect the frontmatter value (used elsewhere as a stable
|
|
// public id), but the on-disk alias path must use the actual folder
|
|
// name — that is what the daemon-staged junction maps to.
|
|
expect(skill.id).toBe('magazine-web-ppt');
|
|
expect(skill.body).toContain(`${SKILLS_CWD_ALIAS}/guizang-ppt/`);
|
|
expect(skill.body).not.toContain(`${SKILLS_CWD_ALIAS}/magazine-web-ppt/`);
|
|
});
|
|
|
|
it('does not emit a preamble for skills without side files', async () => {
|
|
const root = fresh();
|
|
writeSkill(root, 'lone-skill', {
|
|
withAttachments: false,
|
|
body: 'Body without external files.',
|
|
});
|
|
|
|
const skills = await listSkills(root);
|
|
expect(skills).toHaveLength(1);
|
|
const skill = skills[0];
|
|
if (!skill) throw new Error('lone-skill not found');
|
|
|
|
expect(skill.body).not.toContain(SKILLS_CWD_ALIAS);
|
|
expect(skill.body).not.toContain('Skill root');
|
|
expect(skill.body).toContain('Body without external files.');
|
|
});
|
|
});
|
|
|
|
describe('listSkills multi-root + source tagging', () => {
|
|
it('tags entries from the first root as "user" and the second as "built-in"', async () => {
|
|
const userRoot = fresh();
|
|
const builtInRoot = fresh();
|
|
writeSkill(userRoot, 'web-search', {
|
|
description: 'User-imported web search.',
|
|
});
|
|
writeSkill(builtInRoot, 'audio-jingle', {
|
|
description: 'Built-in jingle skill.',
|
|
});
|
|
|
|
const skills = await listSkills([userRoot, builtInRoot]);
|
|
expect(skills).toHaveLength(2);
|
|
const byId = new Map<string, { id: string; source: string }>(
|
|
skills.map((s: { id: string; source: string }) => [s.id, s]),
|
|
);
|
|
expect(byId.get('web-search')?.source).toBe('user');
|
|
expect(byId.get('audio-jingle')?.source).toBe('built-in');
|
|
|
|
rmSync(userRoot, { recursive: true, force: true });
|
|
rmSync(builtInRoot, { recursive: true, force: true });
|
|
});
|
|
|
|
it('lets a user skill shadow a built-in skill of the same id', async () => {
|
|
const userRoot = fresh();
|
|
const builtInRoot = fresh();
|
|
writeSkill(userRoot, 'shared-id', {
|
|
description: 'User override.',
|
|
body: '# Override body',
|
|
});
|
|
writeSkill(builtInRoot, 'shared-id', {
|
|
description: 'Original built-in.',
|
|
body: '# Built-in body',
|
|
});
|
|
|
|
const skills = await listSkills([userRoot, builtInRoot]);
|
|
expect(skills).toHaveLength(1);
|
|
const shadowed = skills[0]!;
|
|
expect(shadowed.source).toBe('user');
|
|
expect(shadowed.body).toContain('Override body');
|
|
|
|
rmSync(userRoot, { recursive: true, force: true });
|
|
rmSync(builtInRoot, { recursive: true, force: true });
|
|
});
|
|
});
|
|
|
|
describe('slugifySkillName', () => {
|
|
it('lowercases, normalises spaces, and strips reserved slugs', () => {
|
|
expect(slugifySkillName('Web Search')).toBe('web-search');
|
|
expect(slugifySkillName(' Multi Word Skill ')).toBe('multi-word-skill');
|
|
expect(slugifySkillName(' ')).toBe('');
|
|
expect(slugifySkillName('..')).toBe('');
|
|
expect(slugifySkillName('a/../b')).toBe('a-b');
|
|
});
|
|
});
|
|
|
|
describe('importUserSkill / deleteUserSkill', () => {
|
|
it('writes a SKILL.md and round-trips through listSkills', async () => {
|
|
const root = fresh();
|
|
try {
|
|
const result = await importUserSkill(root, {
|
|
name: 'Code Review',
|
|
description: 'Review the latest diff.',
|
|
body: '# Review\n\n1. Read.\n2. Comment.',
|
|
triggers: ['code review', 'review my diff'],
|
|
});
|
|
expect(result.id).toBe('Code Review');
|
|
expect(result.slug).toBe('code-review');
|
|
expect(result.dir).toBe(path.join(root, 'code-review'));
|
|
|
|
const skills = await listSkills(root);
|
|
expect(skills).toHaveLength(1);
|
|
const imported = skills[0]!;
|
|
expect(imported.id).toBe('Code Review');
|
|
expect(imported.triggers).toEqual(['code review', 'review my diff']);
|
|
// First (and only) root is treated as the user root.
|
|
expect(imported.source).toBe('user');
|
|
|
|
// Importing the same name again surfaces a CONFLICT error.
|
|
await expect(
|
|
importUserSkill(root, {
|
|
name: 'Code Review',
|
|
body: '# Different body',
|
|
}),
|
|
).rejects.toMatchObject({ code: 'CONFLICT' });
|
|
|
|
await deleteUserSkill(root, 'Code Review');
|
|
const after = await listSkills(root);
|
|
expect(after).toHaveLength(0);
|
|
|
|
// Deleting an already-deleted skill returns NOT_FOUND.
|
|
await expect(deleteUserSkill(root, 'Code Review')).rejects.toMatchObject({
|
|
code: 'NOT_FOUND',
|
|
});
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('rejects empty bodies and impossibly-named skills', async () => {
|
|
const root = fresh();
|
|
try {
|
|
await expect(
|
|
importUserSkill(root, { name: 'foo', body: ' ' }),
|
|
).rejects.toMatchObject({ code: 'BAD_REQUEST' });
|
|
await expect(
|
|
importUserSkill(root, { name: '..', body: '# body' }),
|
|
).rejects.toMatchObject({ code: 'BAD_REQUEST' });
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// Names like '123', 'true', or 'null' are valid skill ids but YAML coerces
|
|
// unquoted scalars to non-strings, which broke the importUserSkill ->
|
|
// listSkills round-trip prior to PR #955 review feedback. The frontmatter
|
|
// emitter now always quotes `name`, so listSkills should round-trip the
|
|
// exact string id we wrote.
|
|
it('round-trips numeric- and boolean-shaped names through listSkills', async () => {
|
|
const cases = ['123', 'true', 'false', 'null', '0'];
|
|
for (const name of cases) {
|
|
const root = fresh();
|
|
try {
|
|
const result = await importUserSkill(root, {
|
|
name,
|
|
body: `# ${name} body`,
|
|
});
|
|
expect(result.id).toBe(name);
|
|
const skills = await listSkills(root);
|
|
expect(skills).toHaveLength(1);
|
|
expect(skills[0]?.id).toBe(name);
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('updateUserSkill', () => {
|
|
it('writes a SKILL.md and shadows a built-in entry on next listSkills', async () => {
|
|
const userRoot = fresh();
|
|
const builtInRoot = fresh();
|
|
try {
|
|
writeSkill(builtInRoot, 'shared-id', {
|
|
description: 'Original built-in.',
|
|
body: '# Original',
|
|
});
|
|
|
|
const result = await updateUserSkill(userRoot, {
|
|
name: 'shared-id',
|
|
description: 'User override.',
|
|
body: '# Override',
|
|
triggers: ['shared trigger'],
|
|
});
|
|
expect(result.slug).toBe('shared-id');
|
|
expect(result.dir).toBe(path.join(userRoot, 'shared-id'));
|
|
|
|
const skills = await listSkills([userRoot, builtInRoot]);
|
|
expect(skills).toHaveLength(1);
|
|
const shadowed = skills[0]!;
|
|
expect(shadowed.source).toBe('user');
|
|
expect(shadowed.body).toContain('Override');
|
|
expect(shadowed.triggers).toEqual(['shared trigger']);
|
|
} finally {
|
|
rmSync(userRoot, { recursive: true, force: true });
|
|
rmSync(builtInRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('rejects empty bodies and impossibly-named skills', async () => {
|
|
const root = fresh();
|
|
try {
|
|
await expect(
|
|
updateUserSkill(root, { name: 'demo', body: ' ' }),
|
|
).rejects.toMatchObject({ code: 'BAD_REQUEST' });
|
|
await expect(
|
|
updateUserSkill(root, { name: '..', body: '# body' }),
|
|
).rejects.toMatchObject({ code: 'BAD_REQUEST' });
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// Regression for mrcfps' PR #955 blocker: editing a built-in skill
|
|
// wrote a shadow folder that contained only a new SKILL.md. The next
|
|
// listSkills() pass surfaced the shadow as the active dir, but
|
|
// /api/skills/:id/files, /example, /assets/* and the system-prompt
|
|
// preamble all resolve through skill.dir, so the bundled assets/,
|
|
// references/, scripts/, and examples/ silently disappeared after
|
|
// save. The fix clones the built-in side tree into the shadow on
|
|
// first edit; subsequent edits leave the user's tweaks alone.
|
|
it('clones built-in side files into the shadow on the first edit', async () => {
|
|
const userRoot = fresh();
|
|
const builtInRoot = fresh();
|
|
try {
|
|
writeSkill(builtInRoot, 'shadow-me', {
|
|
body: '# Original built-in',
|
|
withAttachments: true,
|
|
});
|
|
mkdirSync(path.join(builtInRoot, 'shadow-me', 'references'), {
|
|
recursive: true,
|
|
});
|
|
writeFileSync(
|
|
path.join(builtInRoot, 'shadow-me', 'references', 'notes.md'),
|
|
'# bundled notes',
|
|
);
|
|
mkdirSync(path.join(builtInRoot, 'shadow-me', 'scripts'), {
|
|
recursive: true,
|
|
});
|
|
writeFileSync(
|
|
path.join(builtInRoot, 'shadow-me', 'scripts', 'helper.sh'),
|
|
'#!/bin/sh\necho built-in\n',
|
|
);
|
|
|
|
const before = await listSkills([userRoot, builtInRoot]);
|
|
expect(before).toHaveLength(1);
|
|
expect(before[0]!.source).toBe('built-in');
|
|
|
|
const result = await updateUserSkill(userRoot, {
|
|
name: 'shadow-me',
|
|
body: '# User override',
|
|
sourceDir: before[0]!.dir,
|
|
});
|
|
expect(result.dir).toBe(path.join(userRoot, 'shadow-me'));
|
|
|
|
const after = await listSkills([userRoot, builtInRoot]);
|
|
expect(after).toHaveLength(1);
|
|
const shadowed = after[0]!;
|
|
expect(shadowed.source).toBe('user');
|
|
expect(shadowed.body).toContain('User override');
|
|
|
|
const files = await listSkillFiles(shadowed.dir);
|
|
const paths = files.map((entry) => entry.path).sort();
|
|
expect(paths).toContain('SKILL.md');
|
|
expect(paths).toContain('assets');
|
|
expect(paths).toContain('assets/template.html');
|
|
expect(paths).toContain('references');
|
|
expect(paths).toContain('references/notes.md');
|
|
expect(paths).toContain('scripts');
|
|
expect(paths).toContain('scripts/helper.sh');
|
|
|
|
const noteContent = readFileSync(
|
|
path.join(shadowed.dir, 'references', 'notes.md'),
|
|
'utf8',
|
|
);
|
|
expect(noteContent).toContain('bundled notes');
|
|
} finally {
|
|
rmSync(userRoot, { recursive: true, force: true });
|
|
rmSync(builtInRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('preserves user-edited side files on subsequent edits', async () => {
|
|
const userRoot = fresh();
|
|
const builtInRoot = fresh();
|
|
try {
|
|
writeSkill(builtInRoot, 'edit-twice', {
|
|
body: '# Original',
|
|
withAttachments: true,
|
|
});
|
|
|
|
const initial = await listSkills([userRoot, builtInRoot]);
|
|
await updateUserSkill(userRoot, {
|
|
name: 'edit-twice',
|
|
body: '# First override',
|
|
sourceDir: initial[0]!.dir,
|
|
});
|
|
|
|
const tweakedAsset = path.join(
|
|
userRoot,
|
|
'edit-twice',
|
|
'assets',
|
|
'template.html',
|
|
);
|
|
writeFileSync(tweakedAsset, '<html><body>user-tweaked</body></html>');
|
|
|
|
const next = await listSkills([userRoot, builtInRoot]);
|
|
expect(next[0]!.source).toBe('user');
|
|
|
|
await updateUserSkill(userRoot, {
|
|
name: 'edit-twice',
|
|
body: '# Second override',
|
|
sourceDir: next[0]!.dir,
|
|
});
|
|
|
|
const tweaked = readFileSync(tweakedAsset, 'utf8');
|
|
expect(tweaked).toContain('user-tweaked');
|
|
const final = await listSkills([userRoot, builtInRoot]);
|
|
expect(final[0]!.body).toContain('Second override');
|
|
} finally {
|
|
rmSync(userRoot, { recursive: true, force: true });
|
|
rmSync(builtInRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('listSkillFiles', () => {
|
|
it('returns a flat sorted file/directory list with byte sizes', async () => {
|
|
const root = fresh();
|
|
try {
|
|
writeSkill(root, 'demo-files', { withAttachments: true });
|
|
mkdirSync(path.join(root, 'demo-files', 'references'), { recursive: true });
|
|
writeFileSync(
|
|
path.join(root, 'demo-files', 'references', 'notes.md'),
|
|
'# notes',
|
|
);
|
|
|
|
const entries = await listSkillFiles(path.join(root, 'demo-files'));
|
|
const byPath = new Map(entries.map((entry) => [entry.path, entry]));
|
|
const skillMd = byPath.get('SKILL.md');
|
|
const assetsDir = byPath.get('assets');
|
|
const templateHtml = byPath.get('assets/template.html');
|
|
const referencesDir = byPath.get('references');
|
|
const notesMd = byPath.get('references/notes.md');
|
|
if (!skillMd || !assetsDir || !templateHtml || !referencesDir || !notesMd) {
|
|
throw new Error('expected file tree to include SKILL.md + assets + references');
|
|
}
|
|
expect(skillMd.kind).toBe('file');
|
|
expect(skillMd.size).toBeGreaterThan(0);
|
|
expect(assetsDir.kind).toBe('directory');
|
|
expect(assetsDir.size).toBeNull();
|
|
expect(templateHtml.kind).toBe('file');
|
|
expect(templateHtml.size).toBeGreaterThan(0);
|
|
expect(referencesDir.kind).toBe('directory');
|
|
expect(notesMd.kind).toBe('file');
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it('skips dotfiles and returns an empty list for a missing directory', async () => {
|
|
const root = fresh();
|
|
try {
|
|
writeSkill(root, 'with-dotfile');
|
|
writeFileSync(path.join(root, 'with-dotfile', '.DS_Store'), 'x');
|
|
const entries = await listSkillFiles(path.join(root, 'with-dotfile'));
|
|
expect(entries.find((entry) => entry.path === '.DS_Store')).toBeUndefined();
|
|
|
|
const missing = await listSkillFiles(path.join(root, 'no-such-skill'));
|
|
expect(missing).toEqual([]);
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|