dot-studio 0.0.1 → 0.0.2

package/dist/server/lib/prompt.js

@@ -1,222 +0,0 @@
-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/routes/stages.js

@@ -1,137 +0,0 @@
-// Stage CRUD Routes — with path validation
-import { Hono } from 'hono';
-import fs from 'fs/promises';
-import path from 'path';
-import { createHash } from 'crypto';
-import { stagesDir } from '../lib/config.js';
-const stages = new Hono();
-// ── Helpers ─────────────────────────────────────────────
-function sanitizeStageId(id) {
-    return id
-        .replace(/\.\./g, '')
-        .replace(/[/\\:*?"<>|\x00-\x1f]/g, '')
-        .trim();
-}
-function validateStageId(id) {
-    const clean = sanitizeStageId(id);
-    if (!clean || clean.length === 0)
-        return null;
-    if (clean.length > 128)
-        return null;
-    return clean;
-}
-function normalizeWorkingDir(input) {
-    const trimmed = input.trim().replace(/\/+$/, '');
-    if (!trimmed)
-        return null;
-    return path.resolve(trimmed);
-}
-function stageIdForWorkingDir(workingDir) {
-    return createHash('sha1').update(workingDir).digest('hex').slice(0, 16);
-}
-function stagePathForId(id) {
-    return path.join(stagesDir(), `${id}.json`);
-}
-// ── List Stages ─────────────────────────────────────────
-stages.get('/api/stages', async (c) => {
-    const dir = stagesDir();
-    try {
-        await fs.mkdir(dir, { recursive: true });
-        const files = await fs.readdir(dir);
-        const entries = await Promise.all(files
-            .filter((f) => f.endsWith('.json'))
-            .map(async (file) => {
-            const filePath = path.join(dir, file);
-            try {
-                const [raw, stat] = await Promise.all([
-                    fs.readFile(filePath, 'utf-8'),
-                    fs.stat(filePath),
-                ]);
-                const parsed = JSON.parse(raw);
-                const workingDir = normalizeWorkingDir(parsed.workingDir || '') || '';
-                if (!workingDir) {
-                    return null;
-                }
-                return {
-                    id: file.replace('.json', ''),
-                    workingDir,
-                    updatedAt: stat.mtimeMs,
-                };
-            }
-            catch {
-                return null;
-            }
-        }));
-        return c.json(entries
-            .filter((entry) => entry !== null)
-            .sort((a, b) => b.updatedAt - a.updatedAt));
-    }
-    catch {
-        return c.json([]);
-    }
-});
-// ── Get Stage ───────────────────────────────────────────
-stages.get('/api/stages/:id', async (c) => {
-    const rawId = c.req.param('id');
-    const id = validateStageId(rawId);
-    if (!id)
-        return c.json({ error: 'Invalid stage id' }, 400);
-    const filePath = stagePathForId(id);
-    // Ensure resolved path is within stages dir (prevent traversal)
-    if (!filePath.startsWith(stagesDir())) {
-        return c.json({ error: 'Invalid stage id' }, 400);
-    }
-    try {
-        const raw = await fs.readFile(filePath, 'utf-8');
-        return c.json(JSON.parse(raw));
-    }
-    catch {
-        return c.json({ error: 'Stage not found' }, 404);
-    }
-});
-// ── Save Stage ──────────────────────────────────────────
-stages.put('/api/stages', async (c) => {
-    const body = await c.req.json();
-    const workingDir = normalizeWorkingDir(body.workingDir || '');
-    if (!workingDir) {
-        return c.json({ error: 'workingDir is required' }, 400);
-    }
-    const id = stageIdForWorkingDir(workingDir);
-    const stage = {
-        ...body,
-        workingDir,
-    };
-    const dir = stagesDir();
-    await fs.mkdir(dir, { recursive: true });
-    const filePath = stagePathForId(id);
-    if (!filePath.startsWith(dir)) {
-        return c.json({ error: 'Invalid stage id' }, 400);
-    }
-    await fs.writeFile(filePath, JSON.stringify(stage, null, 2), 'utf-8');
-    const stat = await fs.stat(filePath);
-    return c.json({
-        ok: true,
-        id,
-        workingDir,
-        updatedAt: stat.mtimeMs,
-    });
-});
-// ── Delete Stage ────────────────────────────────────────
-stages.delete('/api/stages/:id', async (c) => {
-    const rawId = c.req.param('id');
-    const id = validateStageId(rawId);
-    if (!id)
-        return c.json({ error: 'Invalid stage id' }, 400);
-    const filePath = stagePathForId(id);
-    if (!filePath.startsWith(stagesDir())) {
-        return c.json({ error: 'Invalid stage id' }, 400);
-    }
-    try {
-        await fs.unlink(filePath);
-        return c.json({ ok: true });
-    }
-    catch {
-        return c.json({ error: 'Stage not found' }, 404);
-    }
-});
-export default stages;