dot-studio 0.0.1 → 0.0.2

package/dist/server/services/draft-service.js

@@ -0,0 +1,367 @@
+/**
+ * draft-service.ts — Filesystem CRUD for `.dance-of-tal/drafts/`
+ *
+ * Tal / Performer / Act: .dance-of-tal/drafts/<kind>/<id>.json
+ * Dance (bundle):        .dance-of-tal/drafts/dance/<id>/draft.json + SKILL.md + sibling dirs
+ * Dance (legacy):        .dance-of-tal/drafts/dance/<id>.json  (lazily migrated to bundle)
+ * Project-local only — no global scope.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { getDotDir, ensureDotDir } from '../lib/dot-source.js';
+import { danceBundleDir, isDanceBundleDraft, scaffoldDanceBundle, readBundleSkillContent, writeBundleSkillContent, } from './dance-bundle-service.js';
+const DRAFT_KINDS = ['tal', 'dance', 'performer', 'act'];
+function isErrnoException(error) {
+    return error instanceof Error;
+}
+function isPerformerDraftFile(draft) {
+    return draft.kind === 'performer' && !!draft.content && typeof draft.content === 'object';
+}
+function isActDraftFile(draft) {
+    return draft.kind === 'act' && !!draft.content && typeof draft.content === 'object';
+}
+function draftsDir(cwd) {
+    return path.join(getDotDir(cwd), 'drafts');
+}
+function kindDir(cwd, kind) {
+    return path.join(draftsDir(cwd), kind);
+}
+function draftFilePath(cwd, kind, id) {
+    return path.join(kindDir(cwd, kind), `${id}.json`);
+}
+function generateDraftId() {
+    const timestamp = Date.now().toString(36);
+    const random = crypto.randomBytes(4).toString('hex');
+    return `draft-${timestamp}-${random}`;
+}
+async function ensureDraftsDir(cwd, kind) {
+    await ensureDotDir(cwd);
+    await fs.mkdir(kindDir(cwd, kind), { recursive: true });
+}
+// ── Create ──────────────────────────────────────────────
+export async function createDraft(cwd, input) {
+    const id = input.id || generateDraftId();
+    const now = Date.now();
+    // Dance drafts use bundle format
+    if (input.kind === 'dance') {
+        const skillContent = typeof input.content === 'string' ? input.content : '';
+        const draft = {
+            id,
+            kind: input.kind,
+            name: input.name,
+            content: skillContent,
+            slug: input.slug,
+            description: input.description,
+            tags: input.tags || [],
+            derivedFrom: input.derivedFrom || null,
+            createdAt: now,
+            updatedAt: now,
+            formatVersion: 2,
+        };
+        await ensureDraftsDir(cwd, input.kind);
+        await scaffoldDanceBundle(cwd, id, skillContent);
+        // Write draft.json metadata (content is stored in SKILL.md, not in draft.json)
+        const metaOnly = { ...draft, content: undefined };
+        await fs.writeFile(path.join(danceBundleDir(cwd, id), 'draft.json'), JSON.stringify(metaOnly, null, 2), 'utf-8');
+        return draft;
+    }
+    // Tal / Performer / Act — legacy JSON single-file
+    const draft = {
+        id,
+        kind: input.kind,
+        name: input.name,
+        content: input.content,
+        slug: input.slug,
+        description: input.description,
+        tags: input.tags || [],
+        derivedFrom: input.derivedFrom || null,
+        createdAt: now,
+        updatedAt: now,
+        formatVersion: 1,
+    };
+    await ensureDraftsDir(cwd, input.kind);
+    await fs.writeFile(draftFilePath(cwd, input.kind, id), JSON.stringify(draft, null, 2), 'utf-8');
+    return draft;
+}
+// ── Read ────────────────────────────────────────────────
+export async function readDraft(cwd, kind, id) {
+    // Dance: try bundle format first
+    if (kind === 'dance') {
+        if (await isDanceBundleDraft(cwd, id)) {
+            return readDanceBundleDraft(cwd, id);
+        }
+        // Try legacy JSON, then lazily migrate
+        const legacy = await readLegacyJsonDraft(cwd, kind, id);
+        if (legacy) {
+            return migrateLegacyDanceDraft(cwd, legacy);
+        }
+        return null;
+    }
+    // Tal / Performer / Act — legacy JSON
+    return readLegacyJsonDraft(cwd, kind, id);
+}
+async function readLegacyJsonDraft(cwd, kind, id) {
+    try {
+        const raw = await fs.readFile(draftFilePath(cwd, kind, id), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function readDanceBundleDraft(cwd, id) {
+    try {
+        const metaRaw = await fs.readFile(path.join(danceBundleDir(cwd, id), 'draft.json'), 'utf-8');
+        const meta = JSON.parse(metaRaw);
+        const skillContent = await readBundleSkillContent(cwd, id);
+        return {
+            ...meta,
+            content: skillContent || '',
+            formatVersion: 2,
+        };
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+/**
+ * Lazily migrate a legacy Dance JSON draft to bundle format.
+ * Creates the bundle directory, writes SKILL.md, writes draft.json, removes the old file.
+ */
+async function migrateLegacyDanceDraft(cwd, legacy) {
+    const skillContent = typeof legacy.content === 'string' ? legacy.content : '';
+    await scaffoldDanceBundle(cwd, legacy.id, skillContent);
+    const migrated = {
+        ...legacy,
+        formatVersion: 2,
+    };
+    const metaOnly = { ...migrated, content: undefined };
+    await fs.writeFile(path.join(danceBundleDir(cwd, legacy.id), 'draft.json'), JSON.stringify(metaOnly, null, 2), 'utf-8');
+    // Remove legacy file (best effort)
+    try {
+        await fs.unlink(draftFilePath(cwd, 'dance', legacy.id));
+    }
+    catch { /* ignore if already gone */ }
+    return migrated;
+}
+/**
+ * Read just the content field from a draft — used by compilers.
+ * Returns the text content for tal/dance, or the full content object for performer/act.
+ */
+export async function readDraftContent(cwd, kind, id) {
+    const draft = await readDraft(cwd, kind, id);
+    if (!draft)
+        return null;
+    return draft.content;
+}
+/**
+ * Read the text content from a draft — convenience for tal/dance.
+ * Returns null if not found or content is not a string.
+ */
+export async function readDraftTextContent(cwd, kind, id) {
+    const content = await readDraftContent(cwd, kind, id);
+    return typeof content === 'string' ? content : null;
+}
+// ── List ────────────────────────────────────────────────
+export async function listDrafts(cwd, kind) {
+    const kinds = kind ? [kind] : [...DRAFT_KINDS];
+    const drafts = [];
+    const seenIds = new Set();
+    for (const k of kinds) {
+        const dir = kindDir(cwd, k);
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (isErrnoException(error) && error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        for (const entry of entries) {
+            // Dance bundle directories
+            if (k === 'dance' && entry.isDirectory()) {
+                try {
+                    const metaPath = path.join(dir, entry.name, 'draft.json');
+                    const raw = await fs.readFile(metaPath, 'utf-8');
+                    const meta = JSON.parse(raw);
+                    const skillContent = await readBundleSkillContent(cwd, entry.name);
+                    drafts.push({
+                        ...meta,
+                        content: skillContent || '',
+                        formatVersion: 2,
+                    });
+                    seenIds.add(meta.id);
+                }
+                catch {
+                    // Skip malformed bundle
+                }
+                continue;
+            }
+            // Legacy JSON files
+            if (!entry.isFile() || !entry.name.endsWith('.json'))
+                continue;
+            try {
+                const raw = await fs.readFile(path.join(dir, entry.name), 'utf-8');
+                const draft = JSON.parse(raw);
+                // Skip if already seen as a bundle draft (shouldn't happen, but safety)
+                if (seenIds.has(draft.id))
+                    continue;
+                drafts.push(draft);
+            }
+            catch {
+                // Skip malformed files
+            }
+        }
+    }
+    return drafts.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+// ── Update ──────────────────────────────────────────────
+export async function updateDraft(cwd, kind, id, patch) {
+    const existing = await readDraft(cwd, kind, id);
+    if (!existing)
+        return null;
+    const updated = {
+        ...existing,
+        ...(patch.name !== undefined ? { name: patch.name } : {}),
+        ...(patch.content !== undefined ? { content: patch.content } : {}),
+        ...(patch.slug !== undefined ? { slug: patch.slug } : {}),
+        ...(patch.description !== undefined ? { description: patch.description } : {}),
+        ...(patch.tags !== undefined ? { tags: patch.tags } : {}),
+        ...(patch.derivedFrom !== undefined ? { derivedFrom: patch.derivedFrom } : {}),
+        updatedAt: Date.now(),
+    };
+    // Dance bundle: write SKILL.md content + metadata to draft.json
+    if (kind === 'dance' && (existing.formatVersion === 2 || await isDanceBundleDraft(cwd, id))) {
+        updated.formatVersion = 2;
+        // Write SKILL.md if content was patched
+        if (patch.content !== undefined && typeof patch.content === 'string') {
+            await writeBundleSkillContent(cwd, id, patch.content);
+        }
+        // Write metadata to draft.json (content excluded from metadata file)
+        const metaOnly = { ...updated, content: undefined };
+        await fs.writeFile(path.join(danceBundleDir(cwd, id), 'draft.json'), JSON.stringify(metaOnly, null, 2), 'utf-8');
+        return updated;
+    }
+    // Legacy JSON
+    await fs.writeFile(draftFilePath(cwd, kind, id), JSON.stringify(updated, null, 2), 'utf-8');
+    return updated;
+}
+function extractReferencedDrafts(draft) {
+    const refs = [];
+    if (isPerformerDraftFile(draft)) {
+        const content = draft.content;
+        if (content.talRef?.kind === 'draft' && typeof content.talRef.draftId === 'string') {
+            refs.push({ kind: 'tal', draftId: content.talRef.draftId });
+        }
+        if (Array.isArray(content.danceRefs)) {
+            for (const ref of content.danceRefs) {
+                if (ref?.kind === 'draft' && typeof ref.draftId === 'string') {
+                    refs.push({ kind: 'dance', draftId: ref.draftId });
+                }
+            }
+        }
+    }
+    if (isActDraftFile(draft)) {
+        const content = draft.content;
+        for (const key of Object.keys(content.participants)) {
+            const participant = content.participants[key];
+            if (participant?.performerRef?.kind === 'draft' && typeof participant.performerRef.draftId === 'string') {
+                refs.push({ kind: 'performer', draftId: participant.performerRef.draftId });
+            }
+        }
+    }
+    return refs;
+}
+export async function findDraftDependents(cwd, targetKind, targetId) {
+    const allDrafts = await listDrafts(cwd);
+    const targetDraft = allDrafts.find((d) => d.kind === targetKind && d.id === targetId);
+    if (!targetDraft) {
+        throw new Error(`Draft not found: ${targetKind}/${targetId}`);
+    }
+    const dependents = [];
+    const processedIds = new Set([targetId]);
+    const queue = [targetId];
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        for (const draft of allDrafts) {
+            if (processedIds.has(draft.id))
+                continue;
+            const refs = extractReferencedDrafts(draft);
+            if (refs.some((r) => r.draftId === currentId)) {
+                processedIds.add(draft.id);
+                const reason = draft.kind === 'performer'
+                    ? `References ${targetKind} draft`
+                    : `Contains performer referencing ${targetKind} draft`;
+                dependents.push({
+                    draftId: draft.id,
+                    kind: draft.kind,
+                    name: draft.name,
+                    source: 'draft',
+                    reason,
+                });
+                queue.push(draft.id);
+            }
+        }
+    }
+    return {
+        target: {
+            draftId: targetDraft.id,
+            kind: targetDraft.kind,
+            name: targetDraft.name,
+            source: 'draft',
+            reason: 'Target',
+        },
+        dependents,
+    };
+}
+async function deleteSingleDraft(cwd, kind, id) {
+    // Dance: try bundle first
+    if (kind === 'dance' && await isDanceBundleDraft(cwd, id)) {
+        await fs.rm(danceBundleDir(cwd, id), { recursive: true, force: true });
+        return true;
+    }
+    // Legacy JSON
+    try {
+        await fs.unlink(draftFilePath(cwd, kind, id));
+        return true;
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+export async function deleteDraft(cwd, kind, id, cascade = false) {
+    const deletedIds = [];
+    if (cascade) {
+        const plan = await findDraftDependents(cwd, kind, id);
+        // Delete dependents first (bottom-up: acts before performers)
+        const sortedDependents = [...plan.dependents].sort((a, b) => {
+            const order = { act: 0, performer: 1, dance: 2, tal: 3 };
+            return (order[a.kind] ?? 9) - (order[b.kind] ?? 9);
+        });
+        for (const dep of sortedDependents) {
+            try {
+                const deleted = await deleteSingleDraft(cwd, dep.kind, dep.draftId);
+                if (deleted)
+                    deletedIds.push(dep.draftId);
+            }
+            catch (error) {
+                if (!isErrnoException(error) || error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+    }
+    const deleted = await deleteSingleDraft(cwd, kind, id);
+    if (deleted) {
+        deletedIds.push(id);
+        return { ok: true, deletedIds };
+    }
+    return { ok: false, deletedIds };
+}

package/dist/server/services/opencode-projection/dance-compiler.js

@@ -0,0 +1,164 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { getAssetPayload, readAsset, danceAssetDir } from '../../lib/dot-source.js';
+import { localSkillProjectionDir, toRelativePath } from './projection-manifest.js';
+import { readDraft } from '../draft-service.js';
+import { isDanceBundleDraft, danceBundleDir, readBundleSkillContent, } from '../dance-bundle-service.js';
+function sanitizeSegment(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function extractDraftDescription(draft) {
+    if (!draft) {
+        return '';
+    }
+    if (typeof draft.description === 'string') {
+        return draft.description;
+    }
+    if (draft.content && typeof draft.content === 'object') {
+        const content = draft.content;
+        if (typeof content.description === 'string') {
+            return content.description;
+        }
+    }
+    return '';
+}
+function parseUrn(urn) {
+    // URN is 4-segment: kind/@owner/stage/name
+    const parts = urn.split('/');
+    const kind = parts[0] ?? '';
+    const ownerWithAt = parts[1] ?? '';
+    const stage = parts[2] ?? '';
+    const name = parts[3] ?? '';
+    return {
+        kind,
+        author: sanitizeSegment(ownerWithAt.replace(/^@/, '')),
+        stage: sanitizeSegment(stage),
+        slug: sanitizeSegment(name),
+    };
+}
+function buildFrontmatter(name, description) {
+    return [
+        '---',
+        `name: ${JSON.stringify(name)}`,
+        `description: ${JSON.stringify(description || 'Generated skill')}`,
+        '---',
+    ].join('\n');
+}
+export async function compileDance(cwd, ref, stageHash, performerId, executionDir, scope = 'workspace', actId) {
+    if (ref.kind === 'registry') {
+        const asset = await readAsset(cwd, ref.urn);
+        const body = await getAssetPayload(cwd, ref.urn);
+        if (!body) {
+            throw new Error(`Dance '${ref.urn}' was not found or has no content.`);
+        }
+        const parsed = parseUrn(ref.urn);
+        const logicalName = parsed.slug;
+        const description = typeof asset?.description === 'string' ? asset.description : parsed.slug;
+        const skillDir = path.join(localSkillProjectionDir(executionDir, stageHash, performerId, scope, actId), logicalName);
+        const filePath = path.join(skillDir, 'SKILL.md');
+        const content = `${buildFrontmatter(logicalName, description)}\n\n${body}`;
+        // Copy bundle sibling dirs (scripts/, references/, assets/) from locally installed dance
+        const bundleDir = danceAssetDir(cwd, ref.urn);
+        const additionalFiles = await copyBundleSiblings(bundleDir, skillDir);
+        return {
+            logicalName,
+            description,
+            filePath,
+            relativePath: toRelativePath(executionDir, filePath),
+            content,
+            additionalFiles,
+        };
+    }
+    // ── Draft ref: check if bundle-backed ─────────────────
+    const isBundle = await isDanceBundleDraft(cwd, ref.draftId);
+    if (isBundle) {
+        const body = await readBundleSkillContent(cwd, ref.draftId);
+        if (!body) {
+            throw new Error(`Dance draft '${ref.draftId}' is missing SKILL.md.`);
+        }
+        const draft = await readDraft(cwd, 'dance', ref.draftId);
+        const logicalName = sanitizeSegment(draft?.name || ref.draftId);
+        const description = extractDraftDescription(draft) || draft?.name || 'Draft skill';
+        const skillDir = path.join(localSkillProjectionDir(executionDir, stageHash, performerId, scope, actId), logicalName);
+        const filePath = path.join(skillDir, 'SKILL.md');
+        const content = `${buildFrontmatter(logicalName, description)}\n\n${body}`;
+        // Copy bundle sibling directories into projection
+        const bundleRoot = danceBundleDir(cwd, ref.draftId);
+        const additionalFiles = await copyBundleSiblings(bundleRoot, skillDir);
+        return {
+            logicalName,
+            description,
+            filePath,
+            relativePath: toRelativePath(executionDir, filePath),
+            content,
+            additionalFiles,
+        };
+    }
+    const draft = await readDraft(cwd, 'dance', ref.draftId);
+    const body = draft ? (typeof draft.content === 'string' ? draft.content : null) : null;
+    if (!draft || !body) {
+        throw new Error(`Dance draft '${ref.draftId}' was not found or has no content.`);
+    }
+    const logicalName = sanitizeSegment(draft.name || ref.draftId);
+    const description = extractDraftDescription(draft) || draft.name || 'Draft skill';
+    const filePath = path.join(localSkillProjectionDir(executionDir, stageHash, performerId, scope, actId), logicalName, 'SKILL.md');
+    const content = `${buildFrontmatter(logicalName, description)}\n\n${body}`;
+    return {
+        logicalName,
+        description,
+        filePath,
+        relativePath: toRelativePath(executionDir, filePath),
+        content,
+        additionalFiles: [],
+    };
+}
+/**
+ * Copy all bundle contents (except SKILL.md itself) from the source bundle directory
+ * into the target projection directory. SKILL.md is handled separately via writeIfChanged.
+ * Returns absolute paths of all copied files.
+ */
+async function copyBundleSiblings(bundleRoot, targetDir) {
+    const copiedFiles = [];
+    let entries;
+    try {
+        entries = await fs.readdir(bundleRoot, { withFileTypes: true, encoding: 'utf-8' });
+    }
+    catch {
+        return copiedFiles; // bundle dir doesn't exist (e.g. SKILL.md-only install)
+    }
+    for (const entry of entries) {
+        if (entry.name === 'SKILL.md')
+            continue; // handled via writeIfChanged
+        const srcPath = path.join(bundleRoot, entry.name);
+        const destPath = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(srcPath, destPath, copiedFiles);
+        }
+        else if (entry.isFile()) {
+            await fs.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.copyFile(srcPath, destPath);
+            copiedFiles.push(destPath);
+        }
+    }
+    return copiedFiles;
+}
+async function copyDirRecursive(src, dest, copiedFiles) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(srcPath, destPath, copiedFiles);
+        }
+        else if (entry.isFile()) {
+            await fs.copyFile(srcPath, destPath);
+            copiedFiles.push(destPath);
+        }
+    }
+}