dot-studio 0.0.1

package/dist/server/lib/prompt.js

@@ -0,0 +1,222 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { createHash } from 'crypto';
+import { getAssetPayload, readAsset } from 'dance-of-tal/lib/registry';
+import { resolveRuntimeModel } from './model-catalog.js';
+import { findRuntimeModelVariant } from '../../shared/model-variants.js';
+import { StudioValidationError } from './opencode-errors.js';
+const CAPABILITY_LOADER_TOOL_NAME = 'read';
+function extractDraftTextContent(draft) {
+    if (!draft) {
+        return null;
+    }
+    if (typeof draft.content === 'string') {
+        return draft.content;
+    }
+    if (draft.content && typeof draft.content === 'object') {
+        const content = draft.content;
+        if (typeof content.content === 'string') {
+            return content.content;
+        }
+        if (typeof content.body === 'string') {
+            return content.body;
+        }
+    }
+    return null;
+}
+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 '';
+}
+async function resolveTalContent(cwd, ref, drafts) {
+    if (!ref) {
+        return null;
+    }
+    if (ref.kind === 'registry') {
+        return getAssetPayload(cwd, ref.urn);
+    }
+    return extractDraftTextContent(drafts[ref.draftId]);
+}
+function draftDisplayName(ref, drafts) {
+    const draft = drafts[ref.draftId];
+    return draft?.name || draft?.description || `draft:${ref.draftId}`;
+}
+function runtimeCapabilityDir(cwd) {
+    return path.join(path.resolve(cwd), '.dot-studio', 'runtime-capabilities');
+}
+async function writeCapabilityDocument(cwd, refKey, payload) {
+    const dir = runtimeCapabilityDir(cwd);
+    await fs.mkdir(dir, { recursive: true });
+    const fileHash = createHash('sha1').update(refKey).digest('hex').slice(0, 16);
+    const filePath = path.join(dir, `${fileHash}.md`);
+    const doc = [
+        `# ${payload.title}`,
+        payload.description ? `Description: ${payload.description}` : 'Description: No description provided.',
+        '',
+        '---',
+        '',
+        payload.body,
+    ].join('\n');
+    await fs.writeFile(filePath, doc, 'utf-8');
+    return filePath;
+}
+async function materializeCapabilityDocument(cwd, ref, drafts) {
+    if (ref.kind === 'registry') {
+        const asset = await readAsset(cwd, ref.urn);
+        const body = await getAssetPayload(cwd, ref.urn);
+        if (!body) {
+            throw new StudioValidationError(`Capability '${ref.urn}' was not found or has no content.`, 'fix_input');
+        }
+        return {
+            urn: ref.urn,
+            description: typeof asset?.description === 'string' ? asset.description : '',
+            path: await writeCapabilityDocument(cwd, `registry:${ref.urn}`, {
+                title: ref.urn,
+                description: typeof asset?.description === 'string' ? asset.description : '',
+                body,
+            }),
+        };
+    }
+    const draft = drafts[ref.draftId];
+    const body = extractDraftTextContent(draft);
+    if (!draft || !body) {
+        throw new StudioValidationError(`Capability draft '${draftDisplayName(ref, drafts)}' was not found or has no content.`, 'fix_input');
+    }
+    return {
+        urn: `draft/${ref.draftId}`,
+        description: extractDraftDescription(draft) || draft.name || 'Draft capability',
+        path: await writeCapabilityDocument(cwd, `draft:${ref.draftId}`, {
+            title: draft.name || `draft/${ref.draftId}`,
+            description: extractDraftDescription(draft) || draft.name || 'Draft capability',
+            body,
+        }),
+    };
+}
+function buildSystemPreamble(toolName) {
+    const lines = [
+        '# Runtime Instructions',
+        'The section named Core Instructions is the always-on instruction layer for your role, rules, and operating logic.',
+        'The section named Optional Capability Catalog lists extra modules you may consult only when the task actually needs them.',
+        'Prefer the minimum capability context needed to complete the task well.',
+        'Do not mention internal runtime wiring, capability loading, or system sections unless the user asks about them directly.',
+    ];
+    if (toolName) {
+        lines.push(`When optional capability context is needed, use the '${toolName}' tool to inspect the capability document path listed in the catalog.`);
+    }
+    return lines.join('\n');
+}
+function buildTalSection(talContent) {
+    if (!talContent) {
+        return [
+            '# Core Instructions',
+            'No core instruction asset is configured. Follow the user request directly and stay consistent with the current session context.',
+        ].join('\n');
+    }
+    return [
+        '# Core Instructions',
+        talContent,
+    ].join('\n\n');
+}
+function buildDanceSection(catalog, toolName) {
+    if (catalog.length === 0) {
+        return [
+            '# Optional Capability Catalog',
+            'No optional capability assets are configured.',
+        ].join('\n');
+    }
+    const lines = [
+        '# Optional Capability Usage',
+        `Capability bodies are available on demand through '${toolName}'. Use the catalog below to decide whether to load one.`,
+        '',
+        '# Optional Capability Catalog',
+    ];
+    for (const entry of catalog) {
+        lines.push(`- ${entry.urn}: ${entry.description || 'No description provided.'}${entry.path ? ` (path: ${entry.path})` : ''}`);
+    }
+    return lines.join('\n');
+}
+function buildRuntimePreferencesSection(input) {
+    if (!input.variantId) {
+        return null;
+    }
+    const lines = [
+        '# Runtime Preferences',
+        `Preferred model variant: ${input.variantId}`,
+    ];
+    if (input.variantSummary) {
+        lines.push(`Variant settings: ${input.variantSummary}`);
+    }
+    lines.push('Apply this preferred runtime profile when supported by the current host and model.');
+    return lines.join('\n');
+}
+export async function buildPromptEnvelope(input) {
+    if (!input.model) {
+        throw new Error('A model is required for this performer. Select a model before compiling or sending prompts.');
+    }
+    const runtimeModel = await resolveRuntimeModel(input.cwd, input.model);
+    const capabilitySnapshot = runtimeModel
+        ? {
+            toolCall: runtimeModel.toolCall,
+            reasoning: runtimeModel.reasoning,
+            attachment: runtimeModel.attachment,
+            temperature: runtimeModel.temperature,
+            modalities: runtimeModel.modalities,
+        }
+        : null;
+    const selectedVariant = runtimeModel
+        ? findRuntimeModelVariant([runtimeModel], input.model.provider, input.model.modelId, input.modelVariant || null)
+        : null;
+    const resolvedVariantId = runtimeModel
+        ? selectedVariant?.id || null
+        : input.modelVariant || null;
+    const drafts = input.drafts || {};
+    if (input.danceRefs.length > 0 && !capabilitySnapshot?.toolCall) {
+        throw new StudioValidationError('The selected model does not support runtime capability loading. Choose a tool-capable model or remove saved capabilities.', 'choose_model');
+    }
+    const talContent = await resolveTalContent(input.cwd, input.talRef, drafts);
+    let deliveryMode = 'tool';
+    let toolName;
+    if (input.danceRefs.length > 0) {
+        toolName = CAPABILITY_LOADER_TOOL_NAME;
+    }
+    const danceCatalog = [];
+    for (const ref of input.danceRefs) {
+        const document = await materializeCapabilityDocument(input.cwd, ref, drafts);
+        danceCatalog.push({
+            urn: document.urn,
+            description: document.description,
+            loadMode: deliveryMode,
+            path: document.path,
+        });
+    }
+    if (deliveryMode === 'tool' && danceCatalog.some((entry) => entry.loadMode === 'tool')) {
+        toolName = toolName || CAPABILITY_LOADER_TOOL_NAME;
+    }
+    const sections = [
+        buildSystemPreamble(toolName),
+        buildTalSection(talContent),
+        buildDanceSection(danceCatalog, toolName),
+        buildRuntimePreferencesSection({
+            variantId: resolvedVariantId,
+            variantSummary: selectedVariant?.summary || null,
+        }),
+    ];
+    return {
+        system: sections.filter(Boolean).join('\n\n').trim() || '// No core instructions or optional capabilities configured',
+        danceCatalog,
+        deliveryMode,
+        capabilitySnapshot,
+        ...(toolName ? { toolName } : {}),
+    };
+}

package/dist/server/lib/request-context.js

@@ -0,0 +1,27 @@
+import path from 'path';
+import { getActiveProjectDir } from './config.js';
+const WORKING_DIR_HEADER = 'x-dot-working-dir';
+function normalizeWorkingDir(input) {
+    const trimmed = input.trim().replace(/\/+$/, '');
+    if (!trimmed) {
+        return null;
+    }
+    return path.resolve(trimmed);
+}
+export function extractRequestWorkingDir(c) {
+    const headerValue = c.req.header(WORKING_DIR_HEADER);
+    if (headerValue) {
+        return normalizeWorkingDir(headerValue);
+    }
+    const queryValue = c.req.query('workingDir');
+    if (queryValue) {
+        return normalizeWorkingDir(queryValue);
+    }
+    return null;
+}
+export function resolveRequestWorkingDir(c) {
+    return extractRequestWorkingDir(c) || getActiveProjectDir();
+}
+export function requestDirectoryQuery(c) {
+    return { directory: resolveRequestWorkingDir(c) };
+}

package/dist/server/lib/runtime-tools.js

@@ -0,0 +1,208 @@
+import { getOpencode } from './opencode.js';
+import { projectMcpEntryEnabled } from '../../shared/project-mcp.js';
+import { readProjectMcpCatalog } from './project-config.js';
+function unique(values) {
+    return Array.from(new Set(values.filter(Boolean)));
+}
+export function describeUnavailableRuntimeTools(resolution) {
+    if (resolution.selectedMcpServers.length === 0 || resolution.unavailableDetails.length === 0) {
+        return null;
+    }
+    const parts = resolution.unavailableDetails.map((detail) => {
+        if (detail.reason === 'connected_but_no_tools_for_model' && detail.toolId) {
+            return `${detail.serverName}: ${detail.toolId} is unavailable for the current model`;
+        }
+        if (detail.reason === 'needs_auth') {
+            return `${detail.serverName}: authentication required`;
+        }
+        if (detail.reason === 'disabled') {
+            return `${detail.serverName}: disabled in project config`;
+        }
+        if (detail.reason === 'not_defined') {
+            return `${detail.serverName}: not defined in project config`;
+        }
+        return `${detail.serverName}: connection failed`;
+    });
+    return parts.join('; ');
+}
+export function buildEnabledToolMap(toolIds) {
+    const enabled = unique(Array.from(toolIds));
+    if (enabled.length === 0) {
+        return undefined;
+    }
+    return enabled.reduce((acc, id) => {
+        acc[id] = true;
+        return acc;
+    }, {});
+}
+function emptyResolution(selectedMcpServers) {
+    return {
+        selectedMcpServers,
+        requestedTools: [],
+        availableTools: [],
+        resolvedTools: [],
+        unavailableTools: [],
+        unavailableDetails: [],
+    };
+}
+async function currentMcpStatus(oc, cwd) {
+    const res = await oc.mcp.status({ directory: cwd });
+    return (res.data || {});
+}
+async function ensureConnectedServer(oc, cwd, serverName, catalog, statusMap) {
+    const config = catalog[serverName];
+    if (!config) {
+        return {
+            statusMap,
+            unavailable: {
+                serverName,
+                reason: 'not_defined',
+                detail: 'Server is not defined in project config.json.',
+            },
+        };
+    }
+    if (!projectMcpEntryEnabled(config)) {
+        return {
+            statusMap,
+            unavailable: {
+                serverName,
+                reason: 'disabled',
+                detail: 'Server is disabled in project config.json.',
+            },
+        };
+    }
+    const current = statusMap[serverName];
+    if (current?.status === 'connected') {
+        return {
+            statusMap,
+            unavailable: null,
+        };
+    }
+    if (current?.status === 'needs_auth') {
+        return {
+            statusMap,
+            unavailable: {
+                serverName,
+                reason: 'needs_auth',
+                detail: 'Server requires authentication before it can connect.',
+            },
+        };
+    }
+    try {
+        await oc.mcp.connect({
+            name: serverName,
+            directory: cwd,
+        });
+    }
+    catch (error) {
+        return {
+            statusMap,
+            unavailable: {
+                serverName,
+                reason: 'connect_failed',
+                detail: error?.message || 'Connection attempt failed.',
+            },
+        };
+    }
+    const refreshed = await currentMcpStatus(oc, cwd);
+    const next = refreshed[serverName];
+    if (next?.status === 'connected') {
+        return {
+            statusMap: refreshed,
+            unavailable: null,
+        };
+    }
+    if (next?.status === 'needs_auth') {
+        return {
+            statusMap: refreshed,
+            unavailable: {
+                serverName,
+                reason: 'needs_auth',
+                detail: 'Server requires authentication before it can connect.',
+            },
+        };
+    }
+    return {
+        statusMap: refreshed,
+        unavailable: {
+            serverName,
+            reason: 'connect_failed',
+            detail: next?.error || 'Server did not reach connected state.',
+        },
+    };
+}
+export async function resolveRuntimeTools(cwd, model, mcpServerNames) {
+    const selectedMcpServers = unique(mcpServerNames);
+    if (selectedMcpServers.length === 0) {
+        return emptyResolution(selectedMcpServers);
+    }
+    const oc = await getOpencode();
+    const catalog = await readProjectMcpCatalog(cwd);
+    let mcpStatus = await currentMcpStatus(oc, cwd);
+    const unavailableDetails = [];
+    for (const serverName of selectedMcpServers) {
+        const ensured = await ensureConnectedServer(oc, cwd, serverName, catalog, mcpStatus);
+        mcpStatus = ensured.statusMap;
+        if (ensured.unavailable) {
+            unavailableDetails.push(ensured.unavailable);
+        }
+    }
+    const requestedTools = unique(selectedMcpServers.flatMap((serverName) => (mcpStatus[serverName]?.tools || [])
+        .map((tool) => tool.name || '')));
+    if (requestedTools.length === 0) {
+        return {
+            ...emptyResolution(selectedMcpServers),
+            unavailableDetails,
+        };
+    }
+    let availableTools = [];
+    if (model) {
+        const toolListRes = await oc.tool.list({
+            provider: model.provider,
+            model: model.modelId,
+            directory: cwd,
+        });
+        const items = (toolListRes.data || []);
+        availableTools = unique(items.map((item) => item.id || ''));
+    }
+    else {
+        const toolIdsRes = await oc.tool.ids({
+            directory: cwd,
+        });
+        availableTools = unique((toolIdsRes.data || []));
+    }
+    const availableSet = new Set(availableTools);
+    const resolvedTools = requestedTools.filter((toolId) => availableSet.has(toolId));
+    const unavailableTools = requestedTools.filter((toolId) => !availableSet.has(toolId));
+    const toolServerNames = new Map();
+    for (const serverName of selectedMcpServers) {
+        for (const tool of (mcpStatus[serverName]?.tools || [])) {
+            const toolId = tool.name || '';
+            if (!toolId)
+                continue;
+            const current = toolServerNames.get(toolId) || [];
+            current.push(serverName);
+            toolServerNames.set(toolId, current);
+        }
+    }
+    for (const toolId of unavailableTools) {
+        for (const serverName of toolServerNames.get(toolId) || []) {
+            unavailableDetails.push({
+                serverName,
+                toolId,
+                reason: 'connected_but_no_tools_for_model',
+                detail: model
+                    ? `${toolId} is not available for ${model.provider}/${model.modelId}.`
+                    : `${toolId} is not available in the current runtime.`,
+            });
+        }
+    }
+    return {
+        selectedMcpServers,
+        requestedTools,
+        availableTools,
+        resolvedTools,
+        unavailableTools,
+        unavailableDetails,
+    };
+}

package/dist/server/routes/assets.js

@@ -0,0 +1,161 @@
+// Asset Routes — using DOT lib directly
+import { Hono } from 'hono';
+import fs from 'fs/promises';
+import path from 'path';
+import { assetFilePath, getDotDir, getGlobalCwd, getGlobalDotDir, readAsset } from 'dance-of-tal/lib/registry';
+import { getRegistryPackage } from 'dance-of-tal/lib/installer';
+import { cached, TTL } from '../lib/cache.js';
+import { resolveRequestWorkingDir } from '../lib/request-context.js';
+const assets = new Hono();
+// ── Asset Scanning ──────────────────────────────────────
+// Scans both local (.dance-of-tal/) and global (~/.dance-of-tal/) dirs
+// Each asset is tagged with source: 'global' | 'stage'
+// Stage assets override global for the same URN
+function normalizeAsset(kind, urn, author, source, content, detail = false) {
+    const slug = urn.split('/')[2];
+    const normalizedAuthor = author.startsWith('@') ? author : `@${author}`;
+    const base = {
+        kind,
+        urn,
+        slug,
+        name: typeof content.name === 'string' && content.name.trim() ? content.name.trim() : slug,
+        author: normalizedAuthor,
+        source,
+        description: typeof content.description === 'string' ? content.description : '',
+    };
+    if (kind === 'performer') {
+        const danceRaw = content.dance;
+        const danceUrns = Array.isArray(danceRaw)
+            ? danceRaw.filter((value) => typeof value === 'string')
+            : typeof danceRaw === 'string'
+                ? [danceRaw]
+                : [];
+        return {
+            ...base,
+            talUrn: typeof content.tal === 'string' ? content.tal : null,
+            danceUrns,
+            actUrn: typeof content.act === 'string' ? content.act : null,
+            model: typeof content.model === 'string' ? content.model : null,
+            mcpConfig: typeof content.mcp_config === 'object' && content.mcp_config !== null ? content.mcp_config : null,
+            tags: Array.isArray(content.tags) ? content.tags : [],
+        };
+    }
+    if (kind === 'act') {
+        return {
+            ...base,
+            entryNode: typeof content.entryNode === 'string' ? content.entryNode : null,
+            nodeCount: typeof content.nodes === 'object' && content.nodes ? Object.keys(content.nodes).length : 0,
+            tags: Array.isArray(content.tags) ? content.tags : [],
+            ...(detail ? {
+                nodes: typeof content.nodes === 'object' && content.nodes ? content.nodes : {},
+                edges: Array.isArray(content.edges) ? content.edges : [],
+                maxIterations: typeof content.maxIterations === 'number' ? content.maxIterations : undefined,
+            } : {}),
+        };
+    }
+    return {
+        ...base,
+        tags: Array.isArray(content.tags) ? content.tags : [],
+        ...(detail && typeof content.content === 'string' ? { content: content.content } : {}),
+    };
+}
+async function fetchRegistryAsset(kind, author, name) {
+    const pkg = await getRegistryPackage(kind, author, name);
+    const urn = typeof pkg.urn === 'string' && pkg.urn ? pkg.urn : `${kind}/@${author.replace(/^@/, '')}/${name}`;
+    const normalized = normalizeAsset(kind, urn, `@${author.replace(/^@/, '')}`, 'registry', pkg.payload, true);
+    return {
+        ...normalized,
+        stars: typeof pkg.stars === 'number' ? pkg.stars : 0,
+        tier: typeof pkg.tier === 'string' ? pkg.tier : undefined,
+        updatedAt: typeof pkg.updatedAt === 'string' ? pkg.updatedAt : undefined,
+    };
+}
+async function scanAssetDir(baseDir, kind, source, resultsMap) {
+    const kindDir = path.join(baseDir, kind);
+    try {
+        const authors = await fs.readdir(kindDir);
+        for (const author of authors) {
+            if (!author.startsWith('@'))
+                continue;
+            const authorDir = path.join(kindDir, author);
+            const stat = await fs.stat(authorDir);
+            if (!stat.isDirectory())
+                continue;
+            const files = await fs.readdir(authorDir);
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                try {
+                    const content = JSON.parse(await fs.readFile(path.join(authorDir, file), 'utf-8'));
+                    const name = file.replace(/\.json$/, '');
+                    const urn = `${kind}/${author}/${name}`;
+                    resultsMap.set(urn, normalizeAsset(kind, urn, author, source, content, false));
+                }
+                catch { /* skip invalid files */ }
+            }
+        }
+    }
+    catch { /* directory doesn't exist */ }
+}
+async function listAssets(cwd, kind) {
+    const resultsMap = new Map();
+    const globalDir = getGlobalDotDir();
+    const localDir = getDotDir(cwd);
+    // 1. Scan Global Directory (Base)
+    await scanAssetDir(globalDir, kind, 'global', resultsMap);
+    // 2. Scan Stage Directory (Overrides)
+    await scanAssetDir(localDir, kind, 'stage', resultsMap);
+    return Array.from(resultsMap.values());
+}
+async function resolveAssetSource(cwd, urn) {
+    try {
+        await fs.access(assetFilePath(cwd, urn));
+        return 'stage';
+    }
+    catch {
+        try {
+            await fs.access(assetFilePath(getGlobalCwd(), urn));
+            return 'global';
+        }
+        catch {
+            return 'stage';
+        }
+    }
+}
+// ── Routes ──────────────────────────────────────────────
+assets.get('/api/assets/:kind', async (c) => {
+    const kind = c.req.param('kind');
+    if (!['tal', 'dance', 'performer', 'act'].includes(kind)) {
+        return c.json({ error: `Invalid kind: ${kind}` }, 400);
+    }
+    const cwd = resolveRequestWorkingDir(c);
+    const assetList = await cached(`assets-${kind}-${cwd}`, TTL.ASSETS, () => listAssets(cwd, kind));
+    return c.json(assetList);
+});
+assets.get('/api/assets/:kind/:author/:name', async (c) => {
+    const { kind, author, name } = c.req.param();
+    const urn = `${kind}/@${author}/${name}`;
+    try {
+        const cwd = resolveRequestWorkingDir(c);
+        const asset = await readAsset(cwd, urn);
+        if (!asset) {
+            return c.json({ error: `Asset not found: ${urn}` }, 404);
+        }
+        const source = await resolveAssetSource(cwd, urn);
+        return c.json(normalizeAsset(kind, urn, `@${author}`, source, asset, true));
+    }
+    catch (err) {
+        return c.json({ error: err.message }, 404);
+    }
+});
+assets.get('/api/assets/registry/:kind/:author/:name', async (c) => {
+    const { kind, author, name } = c.req.param();
+    try {
+        const detail = await cached(`registry-asset-${kind}-${author}-${name}`, TTL.PROVIDERS, () => fetchRegistryAsset(kind, author, name));
+        return c.json(detail);
+    }
+    catch (err) {
+        return c.json({ error: err.message }, 404);
+    }
+});
+export default assets;