@ctrl-spc/cs 0.7.10 → 0.7.11

package/dist/panel3/tools.js

@@ -1,3 +1,5 @@
+import { createEpicHandler, createSprintHandler, listStructureHandler, updateStructureHandler, listStructureArtifactsHandler, getStructureArtifactHandler, searchAgentCardsHandler, createStructureArtifactHandler, updateStructureArtifactHandler } from '../product-tools.js';
+import { listArtifactFoldersHandler, setArtifactFolderHandler, workItemDependencyHandler } from '../product-tools.js';
 /**
  * ═══ AGENT PANEL v3: the tools server, and the per-level allowlist. ═══
  *
@@ -789,6 +791,36 @@ const TOOLS = [
             return `Created Product Idea ${a.title}, id ${id}. No work has started. Only a human can promote it.`;
         },
     },
+    {
+        name: 'list_artifact_folders', levels: ALL,
+        description: 'Read existing artifact folder names and counts before choosing a folder.',
+        input: { work_item_id: z.string().uuid() },
+        handler: async (caller, args) => productResult(await listArtifactFoldersHandler(caller.client, args.work_item_id)),
+    },
+    {
+        name: 'set_artifact_folder', levels: ALL,
+        description: 'Move an artifact into one folder, replacing its previous folder. Null clears it to Unfiled. Content and approval stay unchanged.',
+        input: { artifact_id: z.string().uuid(), folder_name: z.string().max(80).nullable() },
+        handler: async (caller, args) => productResult(await setArtifactFolderHandler(caller.client, args.artifact_id, args.folder_name)),
+    },
+    {
+        name: 'list_work_item_dependencies', levels: ALL,
+        description: 'Read blockers, dependents, and whether this work item is waiting.',
+        input: { work_item_id: z.string().uuid(), },
+        handler: async (caller, args) => productResult(await workItemDependencyHandler(caller.client, 'list', args)),
+    },
+    {
+        name: 'add_work_item_dependency', levels: [1, 2],
+        description: 'Make work_item_id wait for depends_on_work_item_id to reach Done. Same-project work items only; self-links and cycles are refused.',
+        input: { work_item_id: z.string().uuid(), depends_on_work_item_id: z.string().uuid(), },
+        handler: async (caller, args) => productResult(await workItemDependencyHandler(caller.client, 'add', args)),
+    },
+    {
+        name: 'remove_work_item_dependency', levels: [1, 2],
+        description: 'Remove exactly this dependency edge without changing either work item status.',
+        input: { work_item_id: z.string().uuid(), depends_on_work_item_id: z.string().uuid(), },
+        handler: async (caller, args) => productResult(await workItemDependencyHandler(caller.client, 'remove', args)),
+    },
     {
         name: 'place_work_item', levels: [1],
         description: 'Move a work item into an epic or sprint in its project. Null removes placement. Its status stays the same.',
@@ -964,7 +996,7 @@ const TOOLS = [
                 .from('tasks')
                 .select('id, name, description, status, due_date, project_id, created_at, epics(name), sprints(name)')
                 .eq('id', work_item_id), 'read', `work item ${work_item_id}`);
-            const artifacts = await rows(client.from('artifacts').select('id, type, title, created_at').eq('task_id', work_item_id)
+            const artifacts = await rows(client.from('artifacts').select('id, type, title, created_at, folder_name').eq('task_id', work_item_id)
                 .is('deleted_at', null).order('created_at'), 'read', `the artifacts on work item ${work_item_id}`);
             const feedback = await rows(client.from('artifact_feedback').select('*').eq('task_id', work_item_id).order('created_at'), 'read', 'the artifact feedback');
             const decisions = await rows(client.from('decisions').select('id, category, question, state, selected_options, answer_note, related_artifact_id').eq('task_id', work_item_id).order('asked_at'), 'read', 'the work item decisions');
@@ -983,7 +1015,7 @@ const TOOLS = [
                 '',
                 'DECISIONS', JSON.stringify(decisions), 'FEEDBACK', JSON.stringify(feedback), 'COMMENTS', JSON.stringify(comments),
                 `ARTIFACTS  ${artifacts.length}`,
-                listed(artifacts.map((a) => line(a.id, a.type, a.title ?? '(untitled)')), 'none'),
+                listed(artifacts.map((a) => line(a.id, a.type, a.title ?? '(untitled)', `folder: ${a.folder_name ?? 'Unfiled'}`)), 'none'),
             ].join('\n');
         },
     },
@@ -1681,9 +1713,9 @@ const TOOLS = [
         input: { work_item_id: z.string() },
         handler: async ({ client }, args) => {
             const { work_item_id } = args;
-            const artifacts = await rows(client.from('artifacts').select('id, type, format, title, created_at').eq('task_id', work_item_id)
+            const artifacts = await rows(client.from('artifacts').select('id, type, format, title, created_at, folder_name').eq('task_id', work_item_id)
                 .is('deleted_at', null).order('created_at'), 'read', `the artifacts on work item ${work_item_id}`);
-            return listed(artifacts.map((a) => line(a.id, a.type, a.format, a.title ?? '(untitled)')), 'That work item has no artifacts.');
+            return listed(artifacts.map((a) => line(a.id, a.type, a.format, a.title ?? '(untitled)', `folder: ${a.folder_name ?? 'Unfiled'}`)), 'That work item has no artifacts.');
         },
     },
     {
@@ -1694,7 +1726,7 @@ const TOOLS = [
         handler: async ({ client }, args) => {
             const { artifact_id } = args;
             const artifact = await only(client.from('artifacts')
-                .select('id, task_id, type, format, title, content, storage_path, revision, created_at')
+                .select('id, task_id, type, format, title, content, storage_path, revision, created_at, folder_name')
                 .eq('id', artifact_id), 'read', `artifact ${artifact_id}`);
             return [
                 `${artifact.title ?? '(untitled)'}`,
@@ -1702,6 +1734,7 @@ const TOOLS = [
                 `work item    ${artifact.task_id}`,
                 `type         ${artifact.type} (${artifact.format})`,
                 `revision     ${artifact.revision}`,
+                `folder       ${artifact.folder_name ?? 'Unfiled'}`,
                 '',
                 /* A stored file and an empty body are different facts and are said
                    differently. Returning '' for a PNG would read as an artifact with
@@ -2048,34 +2081,65 @@ const TOOLS = [
         },
     },
     {
-        name: 'create_epic',
-        levels: [1],
-        description: 'Create an epic in a project. An epic groups work items that belong to one body of work.',
-        input: { project_id: z.string(), name: z.string().min(1) },
+        name: 'create_epic', levels: [1, 2],
+        description: 'Create an epic with optional description and dates. Read list_structure first to avoid duplicates.',
+        input: { project_id: z.string().uuid(), name: z.string().min(1), description: z.string().optional(), start_date: z.string().optional(), target_date: z.string().optional() },
         handler: async (caller, args) => {
-            const { project_id, name } = args;
-            const epic = await only(caller.client.from('epics').insert({ project_id, name }).select('id, name'), 'create', `an epic called ${name}`);
-            await receipt(caller, 'epic', epic.id, epic.name);
-            return `Created epic ${epic.name}, id ${epic.id}.`;
+            const text = productResult(await createEpicHandler(caller.client, args));
+            const row = JSON.parse(text).epic;
+            await receipt(caller, 'epic', row.id, row.name);
+            return text;
         },
     },
     {
-        name: 'create_sprint',
-        levels: [1],
-        description: 'Create an ordered batch of work in a project. Dates are optional; use them only for a stated calendar constraint.',
-        input: {
-            project_id: z.string(),
-            name: z.string().min(1),
-            start_date: z.string().optional().describe('YYYY-MM-DD'),
-            end_date: z.string().optional().describe('YYYY-MM-DD'),
-        },
+        name: 'create_sprint', levels: [1, 2],
+        description: 'Create an sprint with optional description and dates. Read list_structure first to avoid duplicates.',
+        input: { project_id: z.string().uuid(), name: z.string().min(1), description: z.string().optional(), start_date: z.string().optional(), end_date: z.string().optional() },
         handler: async (caller, args) => {
-            const { project_id, name, start_date, end_date } = args;
-            const sprint = await only(caller.client.from('sprints').insert({ project_id, name, start_date, end_date }).select('id, name'), 'create', `a sprint called ${name}`);
-            await receipt(caller, 'sprint', sprint.id, sprint.name);
-            return `Created sprint ${sprint.name}, id ${sprint.id}.`;
+            const text = productResult(await createSprintHandler(caller.client, args));
+            const row = JSON.parse(text).sprint;
+            await receipt(caller, 'sprint', row.id, row.name);
+            return text;
         },
     },
+    {
+        name: 'list_structure', levels: ALL,
+        description: 'Read project epics and sprints with their descriptions and dates.',
+        input: { project_id: z.string().uuid() },
+        handler: async (caller, args) => productResult(await listStructureHandler(caller.client, { project_id: args.project_id })),
+    },
+    {
+        name: 'update_structure', levels: [1, 2],
+        description: 'Edit an epic or sprint name, description, dates, or archive state. Null clears a date. Epics use target_date; sprints use end_date.',
+        input: { kind: z.enum(['epic', 'sprint']), id: z.string().uuid(), name: z.string().min(1).optional(), description: z.string().optional(), start_date: z.string().nullable().optional(), end_date: z.string().nullable().optional(), target_date: z.string().nullable().optional(), archived: z.boolean().optional() },
+        handler: async (caller, args) => productResult(await updateStructureHandler(caller.client, args)),
+    },
+    {
+        name: 'search_agent_cards', levels: ALL,
+        description: 'Find your agent conversations by literal title or message text, or by work item. Includes archived cards unless specified. Follow next_offset for remaining results. Read-only.',
+        input: { query: z.string().max(500).optional(), work_item_id: z.string().uuid().optional(), archived: z.boolean().optional(), limit: z.number().int().min(1).max(1000).optional(), offset: z.number().int().min(0).optional() },
+        handler: async (caller, args) => productResult(await searchAgentCardsHandler(caller.client, args)),
+    },
+    {
+        name: 'list_structure_artifacts', levels: ALL, description: 'Read active artifacts attached directly to an epic or sprint.',
+        input: { kind: z.enum(['epic', 'sprint']), structure_id: z.string().uuid() },
+        handler: async (caller, args) => productResult(await listStructureArtifactsHandler(caller.client, args.kind, args.structure_id)),
+    },
+    {
+        name: 'get_structure_artifact', levels: ALL, description: 'Read a full epic or sprint artifact and its current revision.',
+        input: { artifact_id: z.string().uuid() },
+        handler: async (caller, args) => productResult(await getStructureArtifactHandler(caller.client, args.artifact_id)),
+    },
+    {
+        name: 'create_structure_artifact', levels: ALL, description: 'Create a titled artifact on an epic or sprint. It appears on its management page.',
+        input: { kind: z.enum(['epic', 'sprint']), structure_id: z.string().uuid(), title: z.string().min(1).max(200), type: z.enum(['analysis', 'plan', 'spec', 'user_story', 'diagram', 'mock', 'wireframe']), format: z.enum(['md', 'html', 'json', 'svg']).optional(), content: z.string().min(1) },
+        handler: async (caller, args) => { const text = productResult(await createStructureArtifactHandler(caller.client, caller.userId, args)); const result = JSON.parse(text); await receipt(caller, result.kind, result.structure.id, result.structure.name); return text; },
+    },
+    {
+        name: 'update_structure_artifact', levels: ALL, description: 'Update an epic or sprint artifact using the revision you read. Concurrent edits refuse without overwriting. archived=true removes it; false restores it.',
+        input: { artifact_id: z.string().uuid(), expected_revision: z.number().int().positive(), title: z.string().min(1).max(200).optional(), type: z.enum(['analysis', 'plan', 'spec', 'user_story', 'diagram', 'mock', 'wireframe']).optional(), format: z.enum(['md', 'html', 'json', 'svg']).optional(), content: z.string().optional(), archived: z.boolean().optional() },
+        handler: async (caller, args) => productResult(await updateStructureArtifactHandler(caller.client, args)),
+    },
     {
         name: 'create_work_item',
         levels: [1],
@@ -2178,6 +2242,7 @@ const TOOLS = [
             + FIREWALL_WRITING_RULE,
         input: {
             work_item_id: z.string(),
+            folder_name: z.string().max(80).nullable().optional().describe('Read list_artifact_folders first to reuse a folder.'),
             title: z.string().min(1),
             content: z.string().min(1),
             type: z.enum(['plan', 'spec', 'analysis', 'diagram', 'mock', 'wireframe', 'user_story']).optional(),
@@ -2187,6 +2252,7 @@ const TOOLS = [
             const a = args;
             const artifact = await only(caller.client.from('artifacts').insert({
                 task_id: a.work_item_id,
+                folder_name: a.folder_name ?? null,
                 title: a.title,
                 content: a.content,
                 type: a.type ?? 'plan',