ultra-builder-pro-cli 0.5.0

package/hooks/workflow_resume.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Restore only the current Ultra workflow boundary after compaction."""
+
+import json
+import sys
+from pathlib import Path
+
+TERMINAL = {"committed", "completed", "done", "cancelled"}
+
+
+def main() -> None:
+    try:
+        data = json.loads(sys.stdin.read() or "{}")
+        data = data if isinstance(data, dict) else {}
+    except json.JSONDecodeError as exc:
+        print(f"[workflow_resume] invalid hook input: {exc}", file=sys.stderr)
+        data = {}
+    start = Path(data.get("cwd") or Path.cwd()).resolve()
+    for root in (start, *start.parents):
+        state_file = root / ".ultra" / "workflow-state.json"
+        if not state_file.is_file():
+            continue
+        try:
+            state = json.loads(state_file.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            print(f"[workflow_resume] cannot read {state_file}: {exc}", file=sys.stderr)
+            break
+        if not isinstance(state, dict) or state.get("status") in TERMINAL:
+            break
+        text = (
+            "[Ultra workflow resumed] "
+            f"command={state.get('command', 'unknown')}; "
+            f"task={state.get('task_id', state.get('task', 'unknown'))}; "
+            f"step={state.get('step', 'unknown')}; status={state.get('status', 'active')}. "
+            "Continue from .ultra/workflow-state.json and verify state through .ultra/state.db."
+        )
+        event = data.get("hook_event_name", "SessionStart")
+        if event == "SessionStart":
+            print(json.dumps({"hookSpecificOutput": {
+                "hookEventName": "SessionStart",
+                "additionalContext": text,
+            }}))
+        else:
+            print(json.dumps({"additionalContext": text}))
+        return
+    print(json.dumps({}))
+
+
+if __name__ == "__main__":
+    main()

package/mcp-server/lib/init-project.cjs

@@ -0,0 +1,162 @@
+'use strict';
+
+// Implementation for MCP tool `task.init_project` and the CLI fallback
+// `ultra-tools init`. Copies the bundled templates/.ultra/ skeleton to the
+// target project root, injecting project metadata into tasks.json.
+//
+// Error contract matches spec/mcp-tools.yaml#task.init_project:
+//   ULTRA_DIR_EXISTS | TEMPLATE_MISSING | TARGET_NOT_DIR | IO_ERROR
+//
+// Not a pure function — touches the filesystem. Kept in lib/ for parity with
+// state-ops/projector modules; Phase 4+ may move cross-tool helpers to
+// mcp-server/tools/ if the catalogue grows.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = process.env.UBP_RUNTIME_ROOT
+  ? path.resolve(process.env.UBP_RUNTIME_ROOT)
+  : path.resolve(__dirname, '..', '..');
+const DEFAULT_TEMPLATE = path.join(REPO_ROOT, 'templates', '.ultra');
+
+class InitProjectError extends Error {
+  constructor(code, message, { retriable = false, cause } = {}) {
+    super(message);
+    this.name = 'InitProjectError';
+    this.code = code;
+    this.retriable = retriable;
+    if (cause) this.cause = cause;
+  }
+}
+
+function resolveTargetDir(target) {
+  if (!target) throw new InitProjectError('TARGET_NOT_DIR', 'target_dir must be a non-empty string');
+  return path.isAbsolute(target) ? target : path.resolve(process.cwd(), target);
+}
+
+function ensureTargetDir(absTarget) {
+  if (!fs.existsSync(absTarget)) {
+    try { fs.mkdirSync(absTarget, { recursive: true }); }
+    catch (err) { throw new InitProjectError('IO_ERROR', `cannot create target_dir: ${err.message}`, { retriable: true, cause: err }); }
+    return;
+  }
+  const stat = fs.statSync(absTarget);
+  if (!stat.isDirectory()) {
+    throw new InitProjectError('TARGET_NOT_DIR', `target_dir exists but is not a directory: ${absTarget}`);
+  }
+}
+
+function ensureTemplate(sourceOverride) {
+  const source = sourceOverride ? path.resolve(sourceOverride) : DEFAULT_TEMPLATE;
+  if (!fs.existsSync(source) || !fs.statSync(source).isDirectory()) {
+    throw new InitProjectError('TEMPLATE_MISSING', `source_template not found: ${source}`);
+  }
+  return source;
+}
+
+function timestampSlug(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, '0');
+  return [
+    date.getFullYear(),
+    pad(date.getMonth() + 1),
+    pad(date.getDate()),
+  ].join('') + '-' + [
+    pad(date.getHours()),
+    pad(date.getMinutes()),
+    pad(date.getSeconds()),
+  ].join('');
+}
+
+function walkRelative(root) {
+  const out = [];
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === '.DS_Store') continue;
+      const full = path.join(dir, entry.name);
+      const rel = path.relative(root, full);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile()) out.push(rel);
+    }
+  }
+  walk(root);
+  return out.sort();
+}
+
+function copyTemplate(source, dest) {
+  const files = walkRelative(source);
+  for (const rel of files) {
+    const from = path.join(source, rel);
+    const to = path.join(dest, rel);
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    fs.copyFileSync(from, to);
+  }
+  return files;
+}
+
+function injectTasksJson(ultraDir, { project_name, project_type, stack }) {
+  const tasksFile = path.join(ultraDir, 'tasks', 'tasks.json');
+  if (!fs.existsSync(tasksFile)) return;
+  let data;
+  try { data = JSON.parse(fs.readFileSync(tasksFile, 'utf8')); }
+  catch (err) { throw new InitProjectError('IO_ERROR', `tasks.json malformed: ${err.message}`, { cause: err }); }
+  const nowIso = new Date().toISOString();
+  data.created = nowIso;
+  data.updated = nowIso;
+  data.project = data.project || {};
+  data.project.name = project_name;
+  if (project_type) data.project.type = project_type;
+  if (stack) data.project.stack = stack;
+  fs.writeFileSync(tasksFile, JSON.stringify(data, null, 2) + '\n');
+}
+
+function initProject({
+  target_dir,
+  project_name,
+  project_type,
+  stack,
+  overwrite = false,
+  source_template,
+} = {}) {
+  if (typeof project_name !== 'string' || project_name.length === 0) {
+    throw new InitProjectError('VALIDATION_ERROR', 'project_name must be non-empty');
+  }
+
+  const absTarget = resolveTargetDir(target_dir);
+  ensureTargetDir(absTarget);
+  const source = ensureTemplate(source_template);
+  const ultraDir = path.join(absTarget, '.ultra');
+
+  let status = 'created';
+  let backupPath;
+  if (fs.existsSync(ultraDir)) {
+    if (!overwrite) {
+      throw new InitProjectError('ULTRA_DIR_EXISTS', `.ultra/ already exists at ${ultraDir}; pass overwrite=true to back up and recreate`);
+    }
+    backupPath = path.join(absTarget, `.ultra.backup.${timestampSlug()}`);
+    try { fs.renameSync(ultraDir, backupPath); }
+    catch (err) { throw new InitProjectError('IO_ERROR', `backup rename failed: ${err.message}`, { retriable: true, cause: err }); }
+    status = 'overwritten';
+  }
+
+  try { fs.mkdirSync(ultraDir, { recursive: true }); }
+  catch (err) { throw new InitProjectError('IO_ERROR', `cannot create .ultra/: ${err.message}`, { retriable: true, cause: err }); }
+
+  let copiedFiles;
+  try {
+    copiedFiles = copyTemplate(source, ultraDir);
+  } catch (err) {
+    throw new InitProjectError('IO_ERROR', `template copy failed: ${err.message}`, { retriable: true, cause: err });
+  }
+
+  injectTasksJson(ultraDir, { project_name, project_type, stack });
+
+  const result = {
+    created_path: ultraDir,
+    status,
+    copied_files: copiedFiles,
+  };
+  if (backupPath) result.backup_path = backupPath;
+  return result;
+}
+
+module.exports = { initProject, InitProjectError, DEFAULT_TEMPLATE };

package/mcp-server/lib/llm-client.cjs

@@ -0,0 +1,157 @@
+'use strict';
+
+// Phase 8A.1 — Unified LLM client over @anthropic-ai/sdk and openai.
+//
+// Provider is inferred from model prefix (claude/opus/sonnet/haiku → Anthropic,
+// gpt/o1/o3 → OpenAI). API keys come from env. The single surface the rest of
+// the code depends on is `client.completeJson({ system, user, maxTokens })`,
+// which returns `{ json, raw, usage, model, provider }` — the model's reply
+// already parsed as JSON (caller handles schema validation on `.json`).
+
+const Anthropic = require('@anthropic-ai/sdk');
+const OpenAI = require('openai');
+
+const PROVIDER_RULES = Object.freeze([
+  { pattern: /^(claude|opus|sonnet|haiku)/i, provider: 'anthropic' },
+  { pattern: /^(gpt|o1|o3)/i,                provider: 'openai'    },
+]);
+
+const DEFAULT_MODEL = 'claude-sonnet-4-6';
+const DEFAULT_MAX_TOKENS = 4096;
+
+class LlmClientError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.name = 'LlmClientError';
+    this.code = code;
+    if (cause) this.cause = cause;
+  }
+}
+
+function inferProvider(model) {
+  if (!model || typeof model !== 'string') return null;
+  for (const rule of PROVIDER_RULES) {
+    if (rule.pattern.test(model)) return rule.provider;
+  }
+  return null;
+}
+
+function resolveProviderKey(provider, apiKey) {
+  if (apiKey) return apiKey;
+  return provider === 'anthropic' ? process.env.ANTHROPIC_API_KEY : process.env.OPENAI_API_KEY;
+}
+
+function createLlmClient({ model, apiKey } = {}) {
+  const resolvedModel = model || process.env.UBP_PLANNER_MODEL || DEFAULT_MODEL;
+  const provider = inferProvider(resolvedModel);
+  if (!provider) {
+    throw new LlmClientError(
+      'LLM_UNSUPPORTED_MODEL',
+      `cannot infer provider from model "${resolvedModel}"`,
+    );
+  }
+  const key = resolveProviderKey(provider, apiKey);
+  if (!key) {
+    const envName = provider === 'anthropic' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY';
+    throw new LlmClientError('NO_LLM_CREDENTIALS', `${envName} not set`);
+  }
+  return provider === 'anthropic'
+    ? buildAnthropicAdapter({ model: resolvedModel, apiKey: key })
+    : buildOpenAiAdapter({ model: resolvedModel, apiKey: key });
+}
+
+function buildAnthropicAdapter({ model, apiKey }) {
+  const sdk = new Anthropic({ apiKey });
+  return {
+    provider: 'anthropic',
+    model,
+    async completeJson({ system, user, maxTokens = DEFAULT_MAX_TOKENS }) {
+      let message;
+      try {
+        message = await sdk.messages.create({
+          model,
+          max_tokens: maxTokens,
+          system,
+          messages: [{ role: 'user', content: user }],
+        });
+      } catch (err) {
+        throw new LlmClientError('LLM_API_ERROR', `Anthropic API error: ${err.message}`, err);
+      }
+      const text = extractAnthropicText(message.content);
+      const usage = {
+        input_tokens: message.usage?.input_tokens ?? 0,
+        output_tokens: message.usage?.output_tokens ?? 0,
+      };
+      return parseCompletionJson({ raw: text, usage, model, provider: 'anthropic' });
+    },
+  };
+}
+
+function buildOpenAiAdapter({ model, apiKey }) {
+  const sdk = new OpenAI({ apiKey });
+  return {
+    provider: 'openai',
+    model,
+    async completeJson({ system, user, maxTokens = DEFAULT_MAX_TOKENS }) {
+      let completion;
+      try {
+        completion = await sdk.chat.completions.create({
+          model,
+          max_tokens: maxTokens,
+          response_format: { type: 'json_object' },
+          messages: [
+            { role: 'system', content: system },
+            { role: 'user',   content: user   },
+          ],
+        });
+      } catch (err) {
+        throw new LlmClientError('LLM_API_ERROR', `OpenAI API error: ${err.message}`, err);
+      }
+      const text = completion.choices?.[0]?.message?.content ?? '';
+      const usage = {
+        input_tokens:  completion.usage?.prompt_tokens     ?? 0,
+        output_tokens: completion.usage?.completion_tokens ?? 0,
+      };
+      return parseCompletionJson({ raw: text, usage, model, provider: 'openai' });
+    },
+  };
+}
+
+function extractAnthropicText(content) {
+  if (!Array.isArray(content)) return '';
+  return content.filter((b) => b && b.type === 'text').map((b) => b.text || '').join('');
+}
+
+function parseCompletionJson({ raw, usage, model, provider }) {
+  const trimmed = stripCodeFence(raw).trim();
+  if (!trimmed) {
+    throw new LlmClientError('LLM_INVALID_JSON', 'LLM returned empty content');
+  }
+  let json;
+  try {
+    json = JSON.parse(trimmed);
+  } catch (err) {
+    throw new LlmClientError(
+      'LLM_INVALID_JSON',
+      `failed to parse LLM response as JSON: ${err.message}`,
+      err,
+    );
+  }
+  return { json, raw, usage, model, provider };
+}
+
+function stripCodeFence(s) {
+  if (!s || typeof s !== 'string') return '';
+  const fenced = s.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```\s*$/);
+  return fenced ? fenced[1] : s;
+}
+
+module.exports = {
+  createLlmClient,
+  inferProvider,
+  LlmClientError,
+  parseCompletionJson,
+  stripCodeFence,
+  DEFAULT_MODEL,
+  DEFAULT_MAX_TOKENS,
+};

package/mcp-server/lib/llm-client.test.cjs

@@ -0,0 +1,156 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  createLlmClient,
+  inferProvider,
+  LlmClientError,
+  parseCompletionJson,
+  stripCodeFence,
+  DEFAULT_MODEL,
+} = require('./llm-client.cjs');
+
+test('inferProvider: claude family → anthropic', () => {
+  assert.equal(inferProvider('claude-sonnet-4-6'), 'anthropic');
+  assert.equal(inferProvider('claude-opus-4-7'), 'anthropic');
+  assert.equal(inferProvider('sonnet-legacy'), 'anthropic');
+  assert.equal(inferProvider('opus-anything'), 'anthropic');
+  assert.equal(inferProvider('haiku-4-5'), 'anthropic');
+});
+
+test('inferProvider: GPT / o1 / o3 → openai', () => {
+  assert.equal(inferProvider('gpt-4o'), 'openai');
+  assert.equal(inferProvider('gpt-5.4'), 'openai');
+  assert.equal(inferProvider('o1-preview'), 'openai');
+  assert.equal(inferProvider('o3-mini'), 'openai');
+});
+
+test('inferProvider: unknown prefix → null', () => {
+  assert.equal(inferProvider('llama-3'), null);
+  assert.equal(inferProvider(''), null);
+  assert.equal(inferProvider(null), null);
+  assert.equal(inferProvider(undefined), null);
+});
+
+test('stripCodeFence: removes ```json ... ``` fence', () => {
+  const input = '```json\n{"a":1}\n```';
+  assert.equal(stripCodeFence(input).trim(), '{"a":1}');
+});
+
+test('stripCodeFence: removes plain ``` ... ``` fence', () => {
+  const input = '```\n{"a":1}\n```';
+  assert.equal(stripCodeFence(input).trim(), '{"a":1}');
+});
+
+test('stripCodeFence: leaves unfenced content alone', () => {
+  assert.equal(stripCodeFence('{"a":1}'), '{"a":1}');
+  assert.equal(stripCodeFence('   '), '   ');
+});
+
+test('stripCodeFence: empty / nullish → empty string', () => {
+  assert.equal(stripCodeFence(''), '');
+  assert.equal(stripCodeFence(null), '');
+  assert.equal(stripCodeFence(undefined), '');
+});
+
+test('parseCompletionJson: valid JSON → parsed object', () => {
+  const r = parseCompletionJson({
+    raw: '{"ok":true,"n":2}',
+    usage: { input_tokens: 10, output_tokens: 5 },
+    model: 'claude-sonnet-4-6',
+    provider: 'anthropic',
+  });
+  assert.deepEqual(r.json, { ok: true, n: 2 });
+  assert.equal(r.usage.input_tokens, 10);
+  assert.equal(r.model, 'claude-sonnet-4-6');
+  assert.equal(r.provider, 'anthropic');
+});
+
+test('parseCompletionJson: fenced JSON → parsed object', () => {
+  const r = parseCompletionJson({
+    raw: '```json\n{"x":42}\n```',
+    usage: {},
+    model: 'gpt-5',
+    provider: 'openai',
+  });
+  assert.deepEqual(r.json, { x: 42 });
+});
+
+test('parseCompletionJson: empty content → LLM_INVALID_JSON', () => {
+  assert.throws(
+    () => parseCompletionJson({ raw: '', usage: {}, model: 'x', provider: 'anthropic' }),
+    (err) => err instanceof LlmClientError && err.code === 'LLM_INVALID_JSON',
+  );
+});
+
+test('parseCompletionJson: malformed JSON → LLM_INVALID_JSON', () => {
+  assert.throws(
+    () => parseCompletionJson({ raw: '{not json', usage: {}, model: 'x', provider: 'anthropic' }),
+    (err) => err instanceof LlmClientError && err.code === 'LLM_INVALID_JSON',
+  );
+});
+
+test('createLlmClient: unknown model → LLM_UNSUPPORTED_MODEL', () => {
+  assert.throws(
+    () => createLlmClient({ model: 'llama-3', apiKey: 'sk-test' }),
+    (err) => err instanceof LlmClientError && err.code === 'LLM_UNSUPPORTED_MODEL',
+  );
+});
+
+test('createLlmClient: missing key → NO_LLM_CREDENTIALS', () => {
+  const savedA = process.env.ANTHROPIC_API_KEY;
+  const savedO = process.env.OPENAI_API_KEY;
+  delete process.env.ANTHROPIC_API_KEY;
+  delete process.env.OPENAI_API_KEY;
+  try {
+    assert.throws(
+      () => createLlmClient({ model: 'claude-sonnet-4-6' }),
+      (err) => err instanceof LlmClientError && err.code === 'NO_LLM_CREDENTIALS',
+    );
+    assert.throws(
+      () => createLlmClient({ model: 'gpt-5' }),
+      (err) => err instanceof LlmClientError && err.code === 'NO_LLM_CREDENTIALS',
+    );
+  } finally {
+    if (savedA !== undefined) process.env.ANTHROPIC_API_KEY = savedA;
+    if (savedO !== undefined) process.env.OPENAI_API_KEY = savedO;
+  }
+});
+
+test('createLlmClient: explicit apiKey bypasses env check + returns adapter shape', () => {
+  const anthropicClient = createLlmClient({ model: 'claude-sonnet-4-6', apiKey: 'sk-test' });
+  assert.equal(anthropicClient.provider, 'anthropic');
+  assert.equal(anthropicClient.model, 'claude-sonnet-4-6');
+  assert.equal(typeof anthropicClient.completeJson, 'function');
+
+  const openaiClient = createLlmClient({ model: 'gpt-5', apiKey: 'sk-test' });
+  assert.equal(openaiClient.provider, 'openai');
+  assert.equal(openaiClient.model, 'gpt-5');
+  assert.equal(typeof openaiClient.completeJson, 'function');
+});
+
+test('createLlmClient: defaults model from env UBP_PLANNER_MODEL', () => {
+  const saved = process.env.UBP_PLANNER_MODEL;
+  process.env.UBP_PLANNER_MODEL = 'gpt-5.4';
+  try {
+    const c = createLlmClient({ apiKey: 'sk-test' });
+    assert.equal(c.model, 'gpt-5.4');
+    assert.equal(c.provider, 'openai');
+  } finally {
+    if (saved === undefined) delete process.env.UBP_PLANNER_MODEL;
+    else process.env.UBP_PLANNER_MODEL = saved;
+  }
+});
+
+test('createLlmClient: falls back to DEFAULT_MODEL when nothing supplied', () => {
+  const savedEnv = process.env.UBP_PLANNER_MODEL;
+  delete process.env.UBP_PLANNER_MODEL;
+  try {
+    const c = createLlmClient({ apiKey: 'sk-test' });
+    assert.equal(c.model, DEFAULT_MODEL);
+  } finally {
+    if (savedEnv !== undefined) process.env.UBP_PLANNER_MODEL = savedEnv;
+  }
+});

package/mcp-server/lib/plan-store.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+// Phase 8A.4b — Persist / load / section-slice the execution-plan artifact.
+//
+// The plan itself is computed by orchestrator/planner/plan-builder.cjs
+// (Functional Core). This module handles IO: atomic write via the shared
+// file-ops helper, read-back, md rendering, and section projection for
+// plan.get.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { writeAtomic } = require('../../adapters/_shared/file-ops.cjs');
+const { buildPlan } = require('../../orchestrator/planner/plan-builder.cjs');
+
+const DEFAULT_ARTIFACT_RELPATH = '.ultra/execution-plan.json';
+
+function renderPlanMd(plan) {
+  const lines = [];
+  lines.push('# Execution Plan');
+  lines.push('');
+  lines.push(`- Waves: ${plan.waves.length}`);
+  lines.push(`- Estimated cost: $${plan.estimated_cost_usd}`);
+  lines.push(`- Estimated duration: ${plan.estimated_duration_min} min`);
+  if (plan.conflict_surface.length > 0) {
+    lines.push(`- Conflicts: ${plan.conflict_surface.length}`);
+  }
+  if (plan.cycles && plan.cycles.length > 0) {
+    lines.push(`- Cycles: ${plan.cycles.length}`);
+  }
+  lines.push('');
+  lines.push('## Waves');
+  lines.push('');
+  for (const w of plan.waves) {
+    lines.push(`### Wave ${w.id} ${w.parallel ? '(parallel)' : '(serial)'}`);
+    for (const id of w.tasks) lines.push(`- ${id}`);
+    if (w.reason) lines.push(`_reason_: ${w.reason}`);
+    lines.push('');
+  }
+  if (plan.conflict_surface.length > 0) {
+    lines.push('## Conflict Surface');
+    lines.push('');
+    for (const c of plan.conflict_surface) {
+      lines.push(`- **files**: ${c.files.join(', ')}; **tasks**: ${c.tasks.join(', ')}; **recommend**: ${c.recommend}`);
+    }
+  }
+  return lines.join('\n') + '\n';
+}
+
+function savePlanArtifact(plan, outPath, format = 'json') {
+  if (!outPath) {
+    const err = new Error('out_path required');
+    err.code = 'WRITE_FAILED';
+    throw err;
+  }
+  const abs = path.resolve(outPath);
+  const content = format === 'md' ? renderPlanMd(plan) : JSON.stringify(plan, null, 2);
+  try {
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    writeAtomic(abs, content);
+  } catch (err) {
+    const wrap = new Error(`cannot write plan: ${err.message}`);
+    wrap.code = 'WRITE_FAILED';
+    wrap.cause = err;
+    throw wrap;
+  }
+  return { plan_path: abs };
+}
+
+function loadPlanArtifact(projectRoot) {
+  const abs = path.resolve(projectRoot, DEFAULT_ARTIFACT_RELPATH);
+  if (!fs.existsSync(abs)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(abs, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function selectSection(plan, section) {
+  switch (section || 'all') {
+    case 'tasks':     return { ownership_forecast: plan.ownership_forecast };
+    case 'topo':      return { waves: plan.waves };
+    case 'conflicts': return { conflict_surface: plan.conflict_surface };
+    case 'all':
+    default:          return plan;
+  }
+}
+
+module.exports = {
+  savePlanArtifact,
+  loadPlanArtifact,
+  selectSection,
+  renderPlanMd,
+  buildPlan,
+  DEFAULT_ARTIFACT_RELPATH,
+};