@nanmicoder/dsh-agent-teams 0.1.0

package/lib/client/activity-model.js

@@ -0,0 +1,70 @@
+/** Pure relationship projections used by the AgentTeams activity panel. */
+/**
+ * Whether an expanded activity panel still belongs to the current session.
+ *
+ * The panel is mounted through a body portal, so React does not remount it
+ * when the conversation route changes. Ownership keeps an expanded panel
+ * from leaking onto the new-session screen (or another conversation) while
+ * its local open state is being reset.
+ */
+export function activityPanelExpandedForSession(open, owner, current) {
+    return open && owner !== undefined && owner === current;
+}
+/** Group tasks by their precomputed dependency depth. */
+export function taskStages(tasks) {
+    const byDepth = new Map();
+    for (const task of tasks) {
+        const depth = Number.isFinite(task.depth) ? Math.max(0, Math.floor(task.depth)) : 0;
+        const stage = byDepth.get(depth) ?? [];
+        stage.push(task);
+        byDepth.set(depth, stage);
+    }
+    return [...byDepth.entries()]
+        .sort(([left], [right]) => left - right)
+        .map(([depth, stageTasks]) => ({
+        depth,
+        tasks: stageTasks.slice().sort((left, right) => left.id.localeCompare(right.id, 'en', { numeric: true })),
+    }));
+}
+/**
+ * Return the complete upstream/downstream chain around one task.
+ *
+ * Traversal uses both dependency directions and remains cycle-safe, so the UI
+ * can highlight every handoff related to the focused task even if malformed
+ * durable data contains a cycle.
+ */
+export function relatedTaskIds(taskId, tasks) {
+    const byId = new Map(tasks.map((task) => [task.id, task]));
+    if (!byId.has(taskId))
+        return new Set();
+    const dependents = new Map();
+    for (const task of tasks) {
+        for (const dependency of task.dependencies) {
+            const targets = dependents.get(dependency) ?? [];
+            targets.push(task.id);
+            dependents.set(dependency, targets);
+        }
+    }
+    const related = new Set();
+    const upstreamSeen = new Set();
+    const downstreamSeen = new Set();
+    const visitUpstream = (id) => {
+        if (upstreamSeen.has(id))
+            return;
+        upstreamSeen.add(id);
+        related.add(id);
+        for (const dependency of byId.get(id)?.dependencies ?? [])
+            visitUpstream(dependency);
+    };
+    const visitDownstream = (id) => {
+        if (downstreamSeen.has(id))
+            return;
+        downstreamSeen.add(id);
+        related.add(id);
+        for (const dependent of dependents.get(id) ?? [])
+            visitDownstream(dependent);
+    };
+    visitUpstream(taskId);
+    visitDownstream(taskId);
+    return related;
+}

package/lib/client/agent-teams-card-definition.js

@@ -0,0 +1,85 @@
+/**
+ * AgentTeams conversation card: a lightweight in-conversation summary shown
+ * when a team is created — the captain's name, the member roster with whale
+ * avatars, and an entry point that re-activates the top-right activity
+ * panel (useful after the floater was closed, or when re-opening an old
+ * session for review).
+ *
+ * The fold anchors to the Harness's durable `tool/call` + `tool/result`
+ * records for `agent_teams_create`. Those are first-party session events, so
+ * the card survives restarts without writing an out-of-repo event type.
+ * @module dsh-agent-teams/client/card
+ */
+/** Parse the only create-call fields the historic card owns. */
+export function parseAgentTeamsCreateArgs(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== 'object' || parsed === null || !('name' in parsed) || typeof parsed.name !== 'string') {
+            return undefined;
+        }
+        const name = parsed.name.trim();
+        if (name === '')
+            return undefined;
+        const cleaned = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+        return { teamId: cleaned === '' ? 'team' : cleaned, name };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Durable first-party tool events folded into one keyed Chat node. */
+export const agentTeamsCardDefinition = {
+    kind: 'agent-teams',
+    target: 'chat',
+    match: (event) => {
+        if (event.type === 'tool/call' && event.data.name === 'agent_teams_create') {
+            return parseAgentTeamsCreateArgs(event.data.arguments) === undefined
+                ? null
+                : { id: String(event.data.callId), role: 'start' };
+        }
+        if (event.type === 'tool/result' && event.data.message.source.kind === 'tool') {
+            return { id: String(event.data.message.source.callId), role: 'update' };
+        }
+        return null;
+    },
+    start: (_context, match) => {
+        if (match.event.type !== 'tool/call') {
+            throw new Error('agent-teams card start requires agent_teams_create tool/call');
+        }
+        const parsed = parseAgentTeamsCreateArgs(match.event.data.arguments);
+        if (parsed === undefined)
+            throw new Error('agent-teams card start requires valid create arguments');
+        return { ...parsed, accepted: false };
+    },
+    update: (context, match) => {
+        if (match.event.type !== 'tool/result')
+            return context.state;
+        const failed = match.event.data.error !== undefined
+            || match.event.data.message.content.some((block) => block.type === 'tool-result' && block.isError === true);
+        if (failed)
+            return context.state;
+        return { ...context.state, accepted: true };
+    },
+    buildViewNode: (context) => {
+        if (context.start === undefined)
+            return null;
+        const state = context.state;
+        if (!state.accepted)
+            return null;
+        return {
+            key: context.key,
+            kind: 'agent-teams',
+            id: context.id,
+            target: 'chat',
+            anchorSeq: context.start.event.seq,
+            location: context.start.location,
+            visibility: 'visible',
+            data: {
+                teamId: state.teamId,
+                captainSessionId: '',
+                teamName: state.name,
+                members: [],
+            },
+        };
+    },
+};

package/lib/client/artwork.js

@@ -0,0 +1,40 @@
+/**
+ * Shared whale artwork lookup for the activity panel and the conversation
+ * card: role keywords map to the packaged role images; the captain always
+ * uses the lead whale.
+ * @module dsh-agent-teams/client/artwork
+ */
+/** Artwork route prefix served by the plugin host half. */
+export const ART_BASE = '/plugins/dsh-agent-teams/assets/';
+/** Whale role artwork per role keyword. */
+const ROLE_ART = [
+    [/resear|analys|investig|explor|data|study|研究|分析|数据|调查|探索|调研/, 'researcher.png'],
+    [/engineer|dev\b|server|backend|\bapi\b|runtime|watcher|contract|工程|后端|服务|接口|开发|代码|编程/, 'engineer.png'],
+    [/\bqa\b|test|verif|quality|测试|质量/, 'qa-engineer.png'],
+    [/design|\bui\b|\bux\b|front|theme|accessib|设计|前端|主题/, 'designer.png'],
+    [/secur|audit|risk|threat|review|安全|审计|审查|风险/, 'security-reviewer.png'],
+    [/docs|writer|product|spec|coordin|撰写|文案|写作|文档|协调/, 'docs-coordinator.png'],
+    [/release|\bbuild\b|deploy|\bops\b|\bci\b|ship|发布|构建|部署/, 'engineer.png'],
+];
+/** Captain artwork (always the lead whale). */
+export const LEAD_ART = `${ART_BASE}team-lead.png`;
+/** Status action artwork per member activity. */
+export const ACTION_ART = {
+    working: `${ART_BASE}action-working.png`,
+    idle: `${ART_BASE}action-sleeping.png`,
+    unknown: `${ART_BASE}action-thinking.png`,
+};
+/**
+ * Member artwork URL, or null when no role matches (initial-letter fallback).
+ * @param name - the member's display name.
+ * @param role - the member's role text.
+ * @returns the artwork URL, or null when unmatched.
+ */
+export function memberArtUrl(name, role) {
+    const identity = `${name} ${role}`.toLowerCase();
+    for (const [pattern, art] of ROLE_ART) {
+        if (pattern.test(identity))
+            return `${ART_BASE}${art}`;
+    }
+    return null;
+}

package/lib/client/index.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createRoot } from 'react-dom/client';
+import { ActivityPanel } from "./ActivityPanel.js";
+import { AgentTeamsCard } from "./AgentTeamsCard.js";
+import { agentTeamsCardDefinition } from "./agent-teams-card-definition.js";
+/** Required services: conversation nodes, slots, and sessions navigation. */
+export const inject = ['conversationEvents', 'slots', 'sessions'];
+/**
+ * Mount the floater through a body portal (the web shell has no top-right
+ * slot) and register the in-conversation team card, whose "activity panel"
+ * button re-activates the floater via a window event — the recovery path
+ * for a closed floater or a re-opened session.
+ */
+export function apply(ctx) {
+    const host = document.createElement('div');
+    host.dataset.agentTeamsHost = '';
+    document.body.appendChild(host);
+    const root = createRoot(host);
+    root.render(_jsx(ActivityPanel, { sessionsList: ctx.sessions.list, openSession: (id) => { ctx.sessions.open(id); } }));
+    ctx.effect(() => () => {
+        root.unmount();
+        host.remove();
+    }, 'agent-teams: activity panel');
+    ctx.conversationEvents.register(agentTeamsCardDefinition);
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'agent-teams',
+        inject: () => ({
+            openSession: (id) => { ctx.sessions.open(id); },
+            currentSessionId: () => ctx.sessions.list.getSnapshot().current,
+        }),
+    }, AgentTeamsCard));
+}