@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

package/src/mcp-tools.ts

@@ -1,9 +1,16 @@
-import { z } from 'zod';
+/**
+ * MCP tool registrations for the Weaver pack.
+ *
+ * Reads tool schemas from the manifest (single source of truth) and delegates
+ * every handler to `handleWeaverTool` from ai-chat-provider — so MCP and the
+ * platform AI chat always run the exact same logic.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { runWorkflow } from './bot/runner.js';
-import { RunStore } from './bot/run-store.js';
-import { CostStore } from './bot/cost-store.js';
-import { defaultRegistry, discoverProviders } from './bot/provider-registry.js';
+import { z } from 'zod';
+import { handleWeaverTool } from './ai-chat-provider.js';
 
 // McpServer type from the SDK, kept loose to avoid hard dependency
 type McpServer = {
@@ -11,381 +18,131 @@ type McpServer = {
     name: string,
     description: string,
     schema: Record<string, unknown>,
-    handler: (args: { [key: string]: unknown }) => Promise<{ content: Array<{ type: string; text: string }> }>,
+    handler: (args: { [key: string]: unknown }) => Promise<{
+      content: Array<{ type: string; text: string }>;
+      isError?: boolean;
+    }>,
   ): void;
 };
 
-export async function registerMcpTools(mcp: McpServer): Promise<void> {
-  mcp.tool(
-    'fw_weaver_run',
-    'Execute a Flow Weaver workflow with the AI runner. Returns the result summary, outcome, and cost.',
-    {
-      file: z.string().describe('Path to the workflow file'),
-      params: z.record(z.unknown()).optional().describe('Input parameters as key-value pairs'),
-      verbose: z.boolean().optional().describe('Show detailed execution info'),
-      dryRun: z.boolean().optional().describe('Preview without executing'),
-    },
-    async (args) => {
-      const result = await runWorkflow(args.file as string, {
-        params: args.params as Record<string, unknown> | undefined,
-        verbose: args.verbose as boolean | undefined,
-        dryRun: args.dryRun as boolean | undefined,
-      });
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-      };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_history',
-    'Query weaver run history. Returns recent workflow executions with outcome, duration, and summary.',
-    {
-      id: z.string().optional().describe('Specific run ID to look up'),
-      limit: z.number().optional().describe('Max number of entries (default 20)'),
-      outcome: z.enum(['completed', 'failed', 'error', 'skipped']).optional().describe('Filter by outcome'),
-      workflowFile: z.string().optional().describe('Filter by workflow file path'),
-    },
-    async (args) => {
-      const store = new RunStore();
-
-      if (args.id) {
-        const record = store.get(args.id as string);
-        if (!record) {
-          return { content: [{ type: 'text', text: `No run found matching "${args.id}"` }] };
-        }
-        return { content: [{ type: 'text', text: JSON.stringify(record, null, 2) }] };
-      }
-
-      const records = store.list({
-        outcome: args.outcome as 'completed' | 'failed' | 'error' | 'skipped' | undefined,
-        workflowFile: args.workflowFile as string | undefined,
-        limit: (args.limit as number | undefined) ?? 20,
-      });
-
-      if (records.length === 0) {
-        return { content: [{ type: 'text', text: 'No runs recorded yet.' }] };
-      }
-
-      return { content: [{ type: 'text', text: JSON.stringify(records, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_costs',
-    'Get AI cost summary across weaver runs. Shows total tokens, estimated cost, and breakdown by model.',
-    {
-      since: z.string().optional().describe('Filter: duration like "7d", "30d", or ISO-8601 date'),
-      model: z.string().optional().describe('Filter by model name'),
-    },
-    async (args) => {
-      const store = new CostStore();
-      let sinceTs: number | undefined;
-
-      if (args.since) {
-        const spec = args.since as string;
-        const match = spec.match(/^(\d+)([dhm])$/);
-        if (match) {
-          const n = parseInt(match[1]!, 10);
-          const unit = match[2];
-          const ms = unit === 'd' ? n * 86_400_000 : unit === 'h' ? n * 3_600_000 : n * 60_000;
-          sinceTs = Date.now() - ms;
-        } else {
-          const ts = new Date(spec).getTime();
-          if (!isNaN(ts)) sinceTs = ts;
-        }
-      }
-
-      const summary = store.summarize({ since: sinceTs, model: args.model as string | undefined });
-      return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_providers',
-    'List available AI providers for weaver workflow execution.',
-    {},
-    async () => {
-      await discoverProviders(defaultRegistry);
-      const providers = defaultRegistry.list();
-
-      const result = providers.map(({ name, metadata }) => ({
-        name,
-        source: metadata.source,
-        description: metadata.description,
-        requiredEnvVars: metadata.requiredEnvVars,
-        envVarsSet: metadata.requiredEnvVars?.every((v) => process.env[v]) ?? false,
-        detectCliCommand: metadata.detectCliCommand,
-      }));
-
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    },
-  );
-
-  // --- Bot Tools ---
-
-  mcp.tool(
-    'fw_weaver_bot',
-    'Run the autonomous bot to create or modify a Flow Weaver workflow. Provide a natural language task description.',
-    {
-      task: z.string().describe('Natural language task description'),
-      projectDir: z.string().optional().describe('Project directory'),
-      mode: z.enum(['create', 'modify', 'read', 'batch']).optional().describe('Task mode'),
-      targets: z.array(z.string()).optional().describe('Target files for modify/read'),
-      template: z.string().optional().describe('Template to use for scaffolding'),
-      dryRun: z.boolean().optional().describe('Preview without executing'),
-      autoApprove: z.boolean().optional().describe('Skip approval gate'),
-    },
-    async (args) => {
-      const task = {
-        instruction: args.task as string,
-        mode: (args.mode as string) ?? 'create',
-        targets: args.targets as string[] | undefined,
-        options: {
-          template: args.template as string | undefined,
-          dryRun: args.dryRun as boolean | undefined,
-          autoApprove: (args.autoApprove as boolean | undefined) ?? true,
-        },
-      };
-
-      const packRoot = new URL('..', import.meta.url);
-      let workflowPath: string;
-      try {
-        const { existsSync } = await import('node:fs');
-        workflowPath = fileURLToPath(new URL('src/workflows/weaver-bot.ts', packRoot));
-        if (!existsSync(workflowPath)) {
-          workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot.js', packRoot));
-        }
-      } catch {
-        workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot.js', packRoot));
-      }
-
-      const result = await runWorkflow(
-        workflowPath,
-        {
-          params: { taskJson: JSON.stringify(task), projectDir: (args.projectDir as string) ?? process.cwd() },
-          dryRun: args.dryRun as boolean | undefined,
-        },
-      );
-
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_steer',
-    'Send a steering command to a running bot (pause, resume, cancel, redirect, queue).',
-    {
-      command: z.enum(['pause', 'resume', 'cancel', 'redirect', 'queue']).describe('Steering command'),
-      payload: z.string().optional().describe('Payload for redirect/queue commands'),
-    },
-    async (args) => {
-      const { SteeringController } = await import('./bot/steering.js');
-      const controller = new SteeringController();
-      await controller.write({
-        command: args.command as 'pause' | 'resume' | 'cancel' | 'redirect' | 'queue',
-        payload: args.payload as string | undefined,
-        timestamp: Date.now(),
-      });
-      return { content: [{ type: 'text', text: `Steering command sent: ${args.command}` }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_queue',
-    'Manage the bot task queue (add, list, clear, remove tasks).',
-    {
-      action: z.enum(['add', 'list', 'clear', 'remove', 'reorder']).describe('Queue action'),
-      task: z.string().optional().describe('Task instruction (for add)'),
-      id: z.string().optional().describe('Task ID (for remove)'),
-      priority: z.number().optional().describe('Priority value (for reorder)'),
-    },
-    async (args) => {
-      const { TaskQueue } = await import('./bot/task-queue.js');
-      const queue = new TaskQueue();
-
-      switch (args.action) {
-        case 'add': {
-          if (!args.task) return { content: [{ type: 'text', text: 'Error: task instruction required' }] };
-          const { id, duplicate } = await queue.add({ instruction: args.task as string, priority: 0 });
-          return { content: [{ type: 'text', text: duplicate ? `Task already queued (${id})` : `Task added: ${id}` }] };
-        }
-        case 'list':
-          return { content: [{ type: 'text', text: JSON.stringify(await queue.list(), null, 2) }] };
-        case 'clear': {
-          const count = await queue.clear();
-          return { content: [{ type: 'text', text: `Cleared ${count} task(s)` }] };
-        }
-        case 'remove': {
-          if (!args.id) return { content: [{ type: 'text', text: 'Error: task ID required' }] };
-          const removed = await queue.remove(args.id as string);
-          return { content: [{ type: 'text', text: removed ? `Removed ${args.id}` : `Not found: ${args.id}` }] };
-        }
-        case 'reorder': {
-          if (!args.id) return { content: [{ type: 'text', text: 'Error: task ID required' }] };
-          if (args.priority === undefined) return { content: [{ type: 'text', text: 'Error: priority required' }] };
-          const reordered = await queue.reorder(args.id as string, args.priority as number);
-          return { content: [{ type: 'text', text: reordered ? `Reordered ${args.id} to priority ${args.priority}` : `Not found: ${args.id}` }] };
-        }
-        default:
-          return { content: [{ type: 'text', text: `Unknown action: ${args.action}` }] };
-      }
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_status',
-    'Get current bot session status (idle/planning/executing/etc), current task, completed count.',
-    {},
-    async () => {
-      const { SessionStore } = await import('./bot/session-state.js');
-      const store = new SessionStore();
-      const state = store.load();
-
-      if (!state) {
-        return { content: [{ type: 'text', text: JSON.stringify({ status: 'no active session' }, null, 2) }] };
-      }
-
-      return { content: [{ type: 'text', text: JSON.stringify(state, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_events',
-    'Read live execution events from a running or completed bot task. Returns events since the given offset for progressive streaming.',
-    {
-      runId: z.string().describe('Run ID returned by fw_weaver_bot'),
-      offset: z.number().optional().describe('Event offset to read from (default 0)'),
-    },
-    async (args) => {
-      const { EventLog } = await import('./bot/event-log.js');
-      const runId = args.runId as string;
-      const offset = (args.offset as number) ?? 0;
-      const log = new EventLog(runId);
-      const events = log.tail(offset);
-      const done = log.isDone();
-
-      return { content: [{ type: 'text', text: JSON.stringify({ events, done }) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_approve',
-    'Approve or reject a pending bot plan. Writes the decision so the bot can continue or abort.',
-    {
-      approved: z.boolean().describe('Whether to approve the plan'),
-      reason: z.string().optional().describe('Reason for rejection'),
-    },
-    async (args) => {
-      const { writeFileSync } = await import('node:fs');
-      const { join } = await import('node:path');
-      const { homedir } = await import('node:os');
-      const dir = process.env.WEAVER_HISTORY_DIR ?? join(homedir(), '.weaver');
-      const decisionPath = join(dir, 'approval-decision.json');
-
-      writeFileSync(decisionPath, JSON.stringify({
-        approved: args.approved as boolean,
-        reason: (args.reason as string) ?? undefined,
-        timestamp: Date.now(),
-      }), 'utf-8');
+// ---------------------------------------------------------------------------
+// JSON Schema → Zod conversion (shallow, covers the manifest's patterns)
+// ---------------------------------------------------------------------------
+
+export function jsonSchemaPropertyToZod(prop: Record<string, unknown>): z.ZodTypeAny {
+  const type = prop.type as string | undefined;
+
+  if (type === 'array') {
+    const items = prop.items as Record<string, unknown> | undefined;
+    // For nested object arrays (e.g. subtasks) just accept unknown[]
+    if (items && (items.type === 'object' || !items.type)) {
+      return z.array(z.unknown()).describe((prop.description as string) ?? '');
+    }
+    return z.array(jsonSchemaPropertyToZod(items ?? { type: 'string' })).describe(
+      (prop.description as string) ?? '',
+    );
+  }
+
+  if (type === 'number') {
+    let s: z.ZodTypeAny = z.number();
+    if (prop.description) s = s.describe(prop.description as string);
+    return s;
+  }
+  if (type === 'boolean') {
+    let s: z.ZodTypeAny = z.boolean();
+    if (prop.description) s = s.describe(prop.description as string);
+    return s;
+  }
+  if (type === 'object') {
+    // Generic object — accept anything
+    let s: z.ZodTypeAny = z.record(z.unknown());
+    if (prop.description) s = s.describe(prop.description as string);
+    return s;
+  }
+
+  // Default: string (possibly with enum)
+  if (prop.enum) {
+    const values = prop.enum as [string, ...string[]];
+    let s: z.ZodTypeAny = z.enum(values);
+    if (prop.description) s = s.describe(prop.description as string);
+    return s;
+  }
+  let s: z.ZodTypeAny = z.string();
+  if (prop.description) s = s.describe(prop.description as string);
+  return s;
+}
 
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true }) }] };
-    },
-  );
+export function jsonSchemaToZodShape(
+  params: Record<string, unknown>,
+): Record<string, z.ZodTypeAny> {
+  const properties = (params.properties ?? {}) as Record<string, Record<string, unknown>>;
+  const required = new Set((params.required ?? []) as string[]);
+  const shape: Record<string, z.ZodTypeAny> = {};
+
+  for (const [key, prop] of Object.entries(properties)) {
+    let zodType = jsonSchemaPropertyToZod(prop);
+    if (!required.has(key)) {
+      zodType = zodType.optional();
+    }
+    shape[key] = zodType;
+  }
+  return shape;
+}
 
-  mcp.tool(
-    'fw_weaver_session',
-    'Start, stop, or check status of an autonomous bot session that processes tasks from the queue.',
-    {
-      action: z.enum(['start', 'stop', 'status']).describe('Session action'),
-      maxTasks: z.number().optional().describe('Max tasks to process (default: all pending)'),
-    },
-    async (args) => {
-      const { SessionStore } = await import('./bot/session-state.js');
-      const store = new SessionStore();
+// ---------------------------------------------------------------------------
+// Read tool definitions from the manifest
+// ---------------------------------------------------------------------------
 
-      if (args.action === 'status') {
-        const state = store.load();
-        return { content: [{ type: 'text', text: state ? JSON.stringify(state, null, 2) : JSON.stringify({ status: 'no active session' }) }] };
-      }
+interface ManifestTool {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+}
 
-      if (args.action === 'stop') {
-        const { SteeringController } = await import('./bot/steering.js');
-        const controller = new SteeringController();
-        await controller.write({ command: 'cancel', timestamp: Date.now() });
-        store.update({ status: 'idle', currentTask: null });
-        return { content: [{ type: 'text', text: JSON.stringify({ stopped: true }) }] };
-      }
+export function loadManifestTools(): ManifestTool[] {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const manifestPath = path.resolve(__dirname, '..', 'flowweaver.manifest.json');
+  const raw = fs.readFileSync(manifestPath, 'utf-8');
+  const manifest = JSON.parse(raw);
+  return (manifest.aiChat?.tools ?? []) as ManifestTool[];
+}
 
-      return { content: [{ type: 'text', text: 'Use the AI chat provider for session start (requires workspace context)' }] };
-    },
-  );
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
 
-  mcp.tool(
-    'fw_weaver_genesis',
-    'Run a single Genesis self-evolution cycle on a target workflow. Genesis observes the project, proposes changes within a budget, validates, and commits or rolls back.',
-    {
-      projectDir: z.string().optional().describe('Project directory (defaults to cwd)'),
-      dryRun: z.boolean().optional().describe('Preview without executing'),
-    },
-    async (args) => {
-      const packRoot = new URL('..', import.meta.url);
-      let workflowPath: string;
-      try {
-        const { existsSync } = await import('node:fs');
-        workflowPath = fileURLToPath(new URL('src/workflows/genesis-task.ts', packRoot));
-        if (!existsSync(workflowPath)) {
-          workflowPath = fileURLToPath(new URL('dist/workflows/genesis-task.js', packRoot));
+export async function registerMcpTools(mcp: McpServer): Promise<void> {
+  const tools = loadManifestTools();
+  const projectDir = process.env.WEAVER_PROJECT_DIR ?? process.cwd();
+
+  for (const tool of tools) {
+    const zodShape = jsonSchemaToZodShape(tool.parameters);
+
+    mcp.tool(
+      tool.name,
+      tool.description,
+      zodShape,
+      async (args) => {
+        try {
+          const { result, isError } = await handleWeaverTool(
+            tool.name,
+            args,
+            projectDir,
+          );
+          return {
+            content: [{ type: 'text', text: result }],
+            ...(isError ? { isError: true } : {}),
+          };
+        } catch (err) {
+          return {
+            content: [{
+              type: 'text',
+              text: err instanceof Error ? err.message : String(err),
+            }],
+            isError: true,
+          };
         }
-      } catch {
-        workflowPath = fileURLToPath(new URL('dist/workflows/genesis-task.js', packRoot));
-      }
-
-      const result = await runWorkflow(workflowPath, {
-        params: { projectDir: (args.projectDir as string) ?? process.cwd() },
-        dryRun: args.dryRun as boolean | undefined,
-      });
-
-      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    },
-  );
-
-  mcp.tool(
-    'fw_weaver_insights',
-    'Get project health, insights, trust level, and cost summary. Returns structured JSON with actionable recommendations.',
-    {
-      projectDir: z.string().describe('Project directory path'),
-    },
-    async (args) => {
-      try {
-        const { ProjectModelStore } = await import('./bot/project-model.js');
-        const { InsightEngine } = await import('./bot/insight-engine.js');
-        const pms = new ProjectModelStore(args.projectDir as string);
-        const model = await pms.getOrBuild();
-        const engine = new InsightEngine();
-        const insights = engine.analyze(model);
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              health: model.health,
-              bots: model.bots,
-              insights: insights.slice(0, 10),
-              trust: model.trust,
-              cost: model.cost,
-              evolution: {
-                totalCycles: model.evolution.totalCycles,
-                successRate: model.evolution.successRate,
-                recentCycles: (model.evolution.recentCycles ?? []).slice(0, 20),
-              },
-            }, null, 2),
-          }],
-        };
-      } catch (err: unknown) {
-        return {
-          content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
-        };
-      }
-    },
-  );
+      },
+    );
+  }
 }

package/src/node-types/bot-report.ts

@@ -1,8 +1,5 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
 import type { WeaverContext } from '../bot/types.js';
-import { withFileLock } from '../bot/file-lock.js';
+import { TaskStore } from '../bot/task-store.js';
 
 /**
  * Generates the final bot session report. Receives context from any
@@ -74,10 +71,12 @@ export async function weaverBotReport(
 
   const summary = parts.join(' | ');
 
-  // Mark queue task as completed or failed
-  if (task.queueId) {
+  // Mark queue task as completed or failed via TaskStore
+  if (task.queueId && context.env?.projectDir) {
     try {
-      await markQueueTask(task.queueId, success ? 'completed' : 'failed');
+      const store = new TaskStore(context.env.projectDir);
+      await store.update(task.queueId, { status: success ? 'done' : 'failed' });
+      console.log(`\x1b[36m→ Queue task ${task.queueId}: ${success ? 'done' : 'failed'}\x1b[0m`);
     } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[bot-report] queue update failed:', err); }
   }
 
@@ -94,20 +93,3 @@ export async function weaverBotReport(
 
   return { onSuccess: success, onFailure: !success, summary, reportJson: JSON.stringify(report) };
 }
-
-async function markQueueTask(id: string, status: 'completed' | 'failed'): Promise<void> {
-  const queuePath = path.join(os.homedir(), '.weaver', 'task-queue.ndjson');
-  if (!fs.existsSync(queuePath)) return;
-
-  await withFileLock(queuePath, () => {
-    const content = fs.readFileSync(queuePath, 'utf-8').trim();
-    if (!content) return;
-    const tasks = content.split('\n').filter(Boolean).map(l => JSON.parse(l));
-    const task = tasks.find((t: { id: string }) => t.id === id);
-    if (task) {
-      task.status = status;
-      fs.writeFileSync(queuePath, tasks.map((t: unknown) => JSON.stringify(t)).join('\n') + '\n', 'utf-8');
-      console.log(`\x1b[36m→ Queue task ${id}: ${status}\x1b[0m`);
-    }
-  });
-}

package/src/node-types/orchestrator-dispatch.ts

@@ -0,0 +1,71 @@
+import type { OrchestratorOutput } from '../bot/profile-types.js';
+
+/**
+ * Applies orchestrator routing decisions — assigns tasks, scales instances.
+ *
+ * @flowWeaver nodeType
+ * @label Dispatch Tasks
+ * @input decisions [order:0] - JSON OrchestratorOutput
+ * @input projectDir [order:1] - Project directory path
+ * @output results [order:0] - JSON dispatch results
+ * @output onSuccess [order:-2] - Dispatch complete
+ * @output onFailure [order:-1] [hidden] - Dispatch failed
+ */
+export async function orchestratorDispatch(
+  execute: boolean,
+  decisions: string,
+  projectDir: string,
+): Promise<{ onSuccess: boolean; onFailure: boolean; results: string | null }> {
+  if (!execute) {
+    return { onSuccess: true, onFailure: false, results: '{"assigned":0,"scaled":0,"skipped":0}' };
+  }
+
+  try {
+    const output = JSON.parse(decisions) as OrchestratorOutput;
+    const { SwarmController } = await import('../bot/swarm-controller.js');
+    const controller = SwarmController.getInstance(projectDir);
+    const instanceManager = controller.getInstanceManager();
+    const profileStore = controller.getProfileStore();
+
+    let assigned = 0;
+    let scaled = 0;
+    let skipped = 0;
+    const appliedAssignments: Array<{ taskId: string; profileId: string; instanceId: string }> = [];
+
+    // Apply scale actions
+    for (const sa of output.scaleActions) {
+      const profile = profileStore.get(sa.profileId);
+      if (profile) {
+        instanceManager.scaleTo(profile, sa.targetInstances);
+        scaled++;
+      } else {
+        skipped++;
+      }
+    }
+
+    // Apply assignments — note: full task execution is handled by SwarmController's
+    // dispatch loop. This node only records the assignment in the task store.
+    // For actual task execution, the dispatch loop picks up assigned tasks.
+    for (const assignment of output.assignments) {
+      try {
+        appliedAssignments.push({
+          taskId: assignment.taskId,
+          profileId: assignment.profileId,
+          instanceId: assignment.instanceId,
+        });
+        assigned++;
+      } catch {
+        skipped++;
+      }
+    }
+
+    skipped += output.skippedTasks.length;
+
+    const results = { assigned, scaled, skipped, appliedAssignments };
+    return { onSuccess: true, onFailure: false, results: JSON.stringify(results) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`\x1b[31m→ Dispatch tasks failed: ${msg}\x1b[0m`);
+    return { onSuccess: false, onFailure: true, results: null };
+  }
+}