dot-studio 0.0.1 → 0.0.2

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

@@ -0,0 +1,195 @@
+import { createHash } from 'crypto';
+import { getAssetPayload } from '../../lib/dot-source.js';
+import { resolveRuntimeModel } from '../../lib/model-catalog.js';
+import { findRuntimeModelVariant } from '../../../shared/model-variants.js';
+import { toRelativePath, resolveAgentIdentity } from './projection-manifest.js';
+import { readDraftTextContent } from '../draft-service.js';
+async function resolveTalContent(cwd, ref) {
+    if (!ref) {
+        return null;
+    }
+    if (ref.kind === 'registry') {
+        return getAssetPayload(cwd, ref.urn);
+    }
+    return readDraftTextContent(cwd, 'tal', ref.draftId);
+}
+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');
+}
+function buildBody(input) {
+    return [
+        buildTalSection(input.talContent),
+        input.collaborationPromptSection || null,
+        input.relationPromptSection || null,
+    ].filter(Boolean).join('\n\n');
+}
+function buildSkillPermissionLines(skillNames) {
+    const lines = ['permission:', '  skill:', '    "*": "deny"'];
+    for (const skillName of skillNames) {
+        lines.push(`    ${JSON.stringify(skillName)}: "allow"`);
+    }
+    return lines;
+}
+function buildTaskPermissionLines(taskAllowlist) {
+    if (taskAllowlist.length === 0) {
+        return [];
+    }
+    const lines = ['  task:', '    "*": "deny"'];
+    for (const agentName of taskAllowlist) {
+        lines.push(`    ${JSON.stringify(agentName)}: "allow"`);
+    }
+    return lines;
+}
+function buildToolsLines(toolMap, posture) {
+    const pairs = Object.entries(toolMap).sort(([left], [right]) => left.localeCompare(right));
+    if (posture === 'plan') {
+        pairs.push(['bash', false], ['edit', false], ['write', false]);
+    }
+    if (pairs.length === 0) {
+        return [];
+    }
+    const lines = ['tools:'];
+    for (const [tool, enabled] of pairs) {
+        lines.push(`  ${JSON.stringify(tool)}: ${enabled ? 'true' : 'false'}`);
+    }
+    return lines;
+}
+function buildFrontmatter(input) {
+    const lines = ['---'];
+    lines.push(`description: ${JSON.stringify(`Agent: ${input.performerName}`)}`);
+    lines.push('mode: primary');
+    if (input.model) {
+        const modelStr = input.model.modelId.startsWith(`${input.model.provider}/`)
+            ? input.model.modelId
+            : `${input.model.provider}/${input.model.modelId}`;
+        lines.push(`model: ${JSON.stringify(modelStr)}`);
+    }
+    if (input.variantId) {
+        lines.push(`variant: ${JSON.stringify(input.variantId)}`);
+    }
+    lines.push(...buildSkillPermissionLines(input.skillNames));
+    lines.push(...buildTaskPermissionLines(input.taskAllowlist || []));
+    lines.push(...buildToolsLines(input.toolMap, input.posture));
+    lines.push('---');
+    return lines.join('\n');
+}
+function buildAgentFile(input) {
+    const identity = resolveAgentIdentity({
+        executionDir: input.executionDir,
+        workspaceHash: input.workspaceHash,
+        performerId: input.performerId,
+        posture: input.posture,
+        scope: input.scope,
+        actId: input.actId,
+    });
+    const frontmatter = buildFrontmatter({
+        performerName: input.performerName,
+        model: input.model,
+        posture: input.posture,
+        variantId: input.variantId,
+        skillNames: input.skillNames,
+        toolMap: input.toolMap,
+        taskAllowlist: input.taskAllowlist,
+    });
+    const content = `${frontmatter}\n\n${input.body}`;
+    return {
+        agentName: identity.agentName,
+        filePath: identity.filePath,
+        relativePath: toRelativePath(input.executionDir, identity.filePath),
+        content,
+    };
+}
+export async function compilePerformer(cwd, input, skills) {
+    const talContent = await resolveTalContent(cwd, input.talRef);
+    let resolvedVariantId = null;
+    if (input.model) {
+        const runtimeModel = await resolveRuntimeModel(cwd, input.model);
+        if (runtimeModel) {
+            const selectedVariant = findRuntimeModelVariant([runtimeModel], input.model.provider, input.model.modelId, input.modelVariant || null);
+            resolvedVariantId = selectedVariant?.id || null;
+        }
+        else {
+            resolvedVariantId = input.modelVariant || null;
+        }
+    }
+    const body = buildBody({
+        talContent,
+        collaborationPromptSection: input.collaborationPromptSection || null,
+        relationPromptSection: input.relationPromptSection || null,
+    });
+    const projectionScope = input.scope === 'stage' ? 'workspace' : (input.scope || 'workspace');
+    const buildFile = buildAgentFile({
+        workspaceHash: input.workspaceHash,
+        performerId: input.performerId,
+        performerName: input.performerName,
+        executionDir: input.executionDir,
+        scope: projectionScope,
+        actId: input.actId,
+        model: input.model,
+        posture: 'build',
+        variantId: resolvedVariantId,
+        skillNames: input.skillNames,
+        toolMap: input.toolMap,
+        taskAllowlist: input.taskAllowlist,
+        body,
+    });
+    // Act scope: build-only (no plan agent — complex multi-performer Acts
+    // make plan mode impractical to control across the whole graph).
+    const includePlan = projectionScope !== 'act';
+    const planFile = includePlan
+        ? buildAgentFile({
+            workspaceHash: input.workspaceHash,
+            performerId: input.performerId,
+            performerName: input.performerName,
+            executionDir: input.executionDir,
+            scope: projectionScope,
+            actId: input.actId,
+            model: input.model,
+            posture: 'plan',
+            variantId: resolvedVariantId,
+            skillNames: input.skillNames,
+            toolMap: input.toolMap,
+            taskAllowlist: input.taskAllowlist,
+            body,
+        })
+        : null;
+    const hashInput = [
+        buildFile.content,
+        planFile?.content,
+        ...skills.map((skill) => skill.content),
+    ].filter(Boolean).join('\n\n');
+    const projectionHash = createHash('sha256').update(hashInput).digest('hex').slice(0, 16);
+    const allFiles = [
+        buildFile.relativePath,
+        ...(planFile ? [planFile.relativePath] : []),
+        ...skills.map((skill) => skill.relativePath),
+    ];
+    return {
+        performerId: input.performerId,
+        agentNames: {
+            build: buildFile.agentName,
+            ...(planFile ? { plan: planFile.agentName } : {}),
+        },
+        agentPaths: {
+            build: buildFile.filePath,
+            ...(planFile ? { plan: planFile.filePath } : {}),
+        },
+        agentContents: {
+            build: buildFile.content,
+            ...(planFile ? { plan: planFile.content } : {}),
+        },
+        skills,
+        projectionHash,
+        allFiles,
+    };
+}

package/dist/server/services/opencode-projection/preview-service.js

@@ -0,0 +1,31 @@
+import { ensurePerformerProjection } from './stage-projection-service.js';
+export function getCompileRequestTargets(request) {
+    return request.requestTargets || request.relatedPerformers || [];
+}
+export async function compileProjectionPreview(cwd, request) {
+    const posture = request.planMode ? 'plan' : 'build';
+    const ensured = await ensurePerformerProjection({
+        performerId: request.performerId || 'preview',
+        performerName: request.performerName || 'Preview',
+        talRef: request.talRef,
+        danceRefs: request.danceRefs,
+        model: request.model,
+        modelVariant: request.modelVariant || null,
+        mcpServerNames: request.mcpServerNames || [],
+        executionDir: cwd,
+        workingDir: cwd,
+        requestTargets: getCompileRequestTargets(request),
+    });
+    return {
+        system: ensured.compiled.agentContents[posture],
+        agent: ensured.compiled.agentNames[posture],
+        danceCatalog: ensured.compiled.skills.map((skill) => ({
+            urn: skill.logicalName,
+            description: skill.description,
+            loadMode: 'tool',
+        })),
+        deliveryMode: 'tool',
+        capabilitySnapshot: ensured.capabilitySnapshot,
+        toolResolution: ensured.toolResolution,
+    };
+}

package/dist/server/services/opencode-projection/projection-manifest.js

@@ -0,0 +1,98 @@
+import fs from 'fs/promises';
+import path from 'path';
+const MANIFEST_FILENAME = 'dot-studio.manifest.json';
+const NAMESPACE = 'dot-studio';
+function manifestPath(executionDir) {
+    return path.join(executionDir, '.opencode', MANIFEST_FILENAME);
+}
+export async function readManifest(executionDir) {
+    try {
+        const raw = await fs.readFile(manifestPath(executionDir), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeManifest(executionDir, manifest) {
+    const filePath = manifestPath(executionDir);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(manifest, null, 2), 'utf-8');
+}
+export async function cleanGroupFiles(executionDir, groupKey, currentFiles) {
+    const existing = await readManifest(executionDir);
+    if (!existing) {
+        return;
+    }
+    const currentSet = new Set(currentFiles);
+    for (const file of existing.groups[groupKey] || []) {
+        if (!currentSet.has(file)) {
+            await fs.rm(path.join(executionDir, file), { force: true, recursive: true }).catch(() => { });
+        }
+    }
+}
+export async function updateManifestGroup(executionDir, workspaceHash, groupKey, files) {
+    const current = (await readManifest(executionDir)) || {
+        version: 1,
+        owner: NAMESPACE,
+        workspaceHash,
+        groups: {},
+    };
+    current.workspaceHash = workspaceHash;
+    current.groups[groupKey] = files;
+    await writeManifest(executionDir, current);
+}
+export async function updateGitExclude(executionDir) {
+    const gitDir = path.join(executionDir, '.git');
+    const gitStat = await fs.stat(gitDir).catch(() => null);
+    if (!gitStat?.isDirectory()) {
+        return;
+    }
+    const excludePath = path.join(gitDir, 'info', 'exclude');
+    const marker = '# dot-studio projection (auto-managed)';
+    const patterns = [
+        marker,
+        '.opencode/agents/dot-studio/',
+        '.opencode/skills/dot-studio/',
+        '.opencode/dot-studio.manifest.json',
+    ];
+    let content = '';
+    try {
+        content = await fs.readFile(excludePath, 'utf-8');
+    }
+    catch {
+        // ignore missing exclude file
+    }
+    if (content.includes(marker)) {
+        return;
+    }
+    await fs.mkdir(path.dirname(excludePath), { recursive: true });
+    const separator = content === '' || content.endsWith('\n') ? '' : '\n';
+    await fs.writeFile(excludePath, content + separator + patterns.join('\n') + '\n', 'utf-8');
+}
+export function agentProjectionDir(executionDir, workspaceHash, scope = 'workspace', actId) {
+    if (scope === 'act' && actId) {
+        return path.join(executionDir, '.opencode', 'agents', NAMESPACE, 'act', workspaceHash, actId);
+    }
+    return path.join(executionDir, '.opencode', 'agents', NAMESPACE, 'workspace', workspaceHash);
+}
+export function localSkillProjectionDir(executionDir, workspaceHash, performerId, scope = 'workspace', actId) {
+    if (scope === 'act' && actId) {
+        return path.join(executionDir, '.opencode', 'skills', NAMESPACE, 'act', workspaceHash, actId, performerId);
+    }
+    return path.join(executionDir, '.opencode', 'skills', NAMESPACE, 'workspace', workspaceHash, performerId);
+}
+export function toRelativePath(executionDir, absPath) {
+    return path.relative(executionDir, absPath);
+}
+/**
+ * Single source of truth for agent identity.
+ * agentName is mechanically derived from filePath — never manually assembled.
+ */
+export function resolveAgentIdentity(input) {
+    const dir = agentProjectionDir(input.executionDir, input.workspaceHash, input.scope, input.actId);
+    const fileName = `${input.performerId}--${input.posture}.md`;
+    const filePath = path.join(dir, fileName);
+    const agentName = path.relative(path.join(input.executionDir, '.opencode', 'agents'), filePath).replace(/\.md$/, '');
+    return { agentName, filePath, fileName };
+}

package/dist/server/services/opencode-projection/stage-projection-service.js

@@ -0,0 +1,188 @@
+import fs from 'fs/promises';
+import { createHash } from 'crypto';
+import path from 'path';
+import { getOpencode } from '../../lib/opencode.js';
+import { resolveRuntimeModel } from '../../lib/model-catalog.js';
+import { resolveRuntimeTools } from '../../lib/runtime-tools.js';
+import { cleanGroupFiles, updateGitExclude, updateManifestGroup, resolveAgentIdentity, } from './projection-manifest.js';
+import { compileDance } from './dance-compiler.js';
+import { compilePerformer } from './performer-compiler.js';
+import { COLLABORATION_TOOL_NAMES, LEGACY_COLLABORATION_TOOL_NAMES } from '../act-runtime/act-tools.js';
+function compileMentionRelations(targets) {
+    if (targets.length === 0) {
+        return { taskAllowlist: [], promptSection: null };
+    }
+    const lines = [
+        '# Available Agents',
+        '',
+        'The following agents are available for @mention in this context.',
+        'Use the `task` tool only when it is actually useful, and only with the allowed agent names below.',
+        '',
+    ];
+    for (const target of targets) {
+        lines.push(`- **${target.performerName}**: use \`task\` with agent="${target.agentName}"${target.description ? ` — ${target.description}` : ''}`);
+    }
+    return {
+        taskAllowlist: targets.map((target) => target.agentName),
+        promptSection: lines.join('\n'),
+    };
+}
+function computeWorkspaceHash(workingDir) {
+    return createHash('sha1').update(workingDir).digest('hex').slice(0, 12);
+}
+function groupKey(performerId) {
+    return `performer:${performerId}`;
+}
+async function writeIfChanged(filePath, content) {
+    const current = await fs.readFile(filePath, 'utf-8').catch(() => null);
+    if (current === content) {
+        return false;
+    }
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+    return true;
+}
+async function allMcpToolIds(cwd) {
+    const oc = await getOpencode();
+    const res = await oc.mcp.status({ directory: cwd });
+    const statusMap = ((res && typeof res === 'object' && 'data' in res ? res.data : {}) || {});
+    return Array.from(new Set(Object.values(statusMap).flatMap((entry) => (entry?.tools || [])
+        .map((tool) => (typeof tool?.name === 'string' ? tool.name : ''))
+        .filter((toolId) => toolId.length > 0))));
+}
+function buildProjectedToolMap(allToolIds, resolvedToolIds) {
+    const resolved = new Set(resolvedToolIds);
+    return Object.fromEntries(allToolIds.map((toolId) => [toolId, resolved.has(toolId)]));
+}
+async function resolveCapabilitySnapshot(cwd, model) {
+    if (!model) {
+        return null;
+    }
+    const runtimeModel = await resolveRuntimeModel(cwd, model);
+    if (!runtimeModel) {
+        return null;
+    }
+    return {
+        toolCall: runtimeModel.toolCall,
+        reasoning: runtimeModel.reasoning,
+        attachment: runtimeModel.attachment,
+        temperature: runtimeModel.temperature,
+        modalities: runtimeModel.modalities,
+    };
+}
+export async function ensurePerformerProjection(input) {
+    const workspaceHash = computeWorkspaceHash(input.workingDir);
+    const toolResolution = await resolveRuntimeTools(input.executionDir, input.model, input.mcpServerNames);
+    const toolMap = buildProjectedToolMap(await allMcpToolIds(input.executionDir), toolResolution.resolvedTools);
+    if (input.extraTools) {
+        for (const tool of input.extraTools) {
+            toolMap[tool.name] = true;
+        }
+    }
+    const skills = [];
+    for (const ref of input.danceRefs) {
+        skills.push(await compileDance(input.executionDir, ref, workspaceHash, input.performerId, input.executionDir, input.scope || 'workspace', input.actId));
+    }
+    const requestTargets = (input.requestTargets || []).map((target) => ({
+        performerId: target.performerId,
+        performerName: target.performerName,
+        agentName: getProjectedAgentName(input.workingDir, target.performerId, 'build', input.scope, input.actId),
+        description: target.description || '',
+    }));
+    const requestProjection = compileMentionRelations(requestTargets);
+    const compileScope = input.scope === 'workspace' ? 'stage' : input.scope;
+    const compiled = await compilePerformer(input.executionDir, {
+        performerId: input.performerId,
+        performerName: input.performerName,
+        talRef: input.talRef,
+        model: input.model,
+        modelVariant: input.modelVariant || null,
+        workspaceHash,
+        executionDir: input.executionDir,
+        scope: compileScope || 'stage',
+        actId: input.actId,
+        skillNames: skills.map((skill) => skill.logicalName),
+        toolMap,
+        taskAllowlist: requestProjection.taskAllowlist,
+        collaborationPromptSection: input.collaborationPromptSection || null,
+        relationPromptSection: requestProjection.promptSection,
+    }, skills);
+    let changed = false;
+    if (input.extraTools) {
+        // Clean stale act tool files that don't belong to the current extra tools set.
+        // This prevents zombie tools from deleted/renamed acts lingering in OpenCode's cache.
+        const currentToolNames = new Set(input.extraTools.map((t) => t.name));
+        const collaborationToolNames = new Set([
+            ...COLLABORATION_TOOL_NAMES,
+            ...LEGACY_COLLABORATION_TOOL_NAMES,
+        ]);
+        const toolsDir = path.join(input.executionDir, '.opencode', 'tools');
+        try {
+            const existing = await fs.readdir(toolsDir);
+            for (const file of existing) {
+                if (file.endsWith('.ts')) {
+                    const toolName = file.replace(/\.ts$/, '');
+                    if (collaborationToolNames.has(toolName) && !currentToolNames.has(toolName)) {
+                        await fs.rm(path.join(toolsDir, file), { force: true }).catch(() => { });
+                        changed = true;
+                    }
+                }
+            }
+        }
+        catch {
+            // tools dir may not exist yet
+        }
+        for (const tool of input.extraTools) {
+            const toolPath = path.join(input.executionDir, '.opencode', 'tools', `${tool.name}.ts`);
+            compiled.allFiles.push(toolPath);
+            changed = (await writeIfChanged(toolPath, tool.content)) || changed;
+        }
+    }
+    await cleanGroupFiles(input.executionDir, groupKey(input.performerId), compiled.allFiles);
+    for (const skill of skills) {
+        changed = (await writeIfChanged(skill.filePath, skill.content)) || changed;
+        // Track additional bundle files (scripts/, references/, assets/) in the manifest.
+        // copyBundleSiblings already wrote these files; we just need to check if any
+        // were new or updated so that opencode reloads when bundle content changes.
+        if (skill.additionalFiles.length > 0) {
+            compiled.allFiles.push(...skill.additionalFiles);
+            // Mark changed if any extra file is newer than the agent file (proxy for freshness)
+            if (!changed) {
+                for (const extra of skill.additionalFiles) {
+                    const stat = await fs.stat(extra).catch(() => null);
+                    const agentStat = await fs.stat(skill.filePath).catch(() => null);
+                    if (stat && agentStat && stat.mtimeMs > agentStat.mtimeMs) {
+                        changed = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    changed = (await writeIfChanged(compiled.agentPaths.build, compiled.agentContents.build)) || changed;
+    if (compiled.agentPaths.plan && compiled.agentContents.plan) {
+        changed = (await writeIfChanged(compiled.agentPaths.plan, compiled.agentContents.plan)) || changed;
+    }
+    await updateManifestGroup(input.executionDir, workspaceHash, groupKey(input.performerId), compiled.allFiles);
+    await updateGitExclude(input.executionDir);
+    if (changed) {
+        const oc = await getOpencode();
+        await oc.instance.dispose({ directory: input.executionDir }).catch(() => { });
+    }
+    return {
+        compiled,
+        toolResolution,
+        capabilitySnapshot: await resolveCapabilitySnapshot(input.executionDir, input.model),
+    };
+}
+export function getProjectedAgentName(workingDir, performerId, posture, scope = 'workspace', actId) {
+    const workspaceHash = computeWorkspaceHash(workingDir);
+    return resolveAgentIdentity({
+        executionDir: workingDir,
+        workspaceHash,
+        performerId,
+        posture,
+        scope,
+        actId,
+    }).agentName;
+}