fa-mcp-sdk 0.4.60 → 0.4.64

package/cli-template/.claude/skills/deploy-mcp/scripts/gitlab-push.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+/**
+ * Create a project on a GitLab server and push the current directory to it.
+ *
+ * Resolves groupId from --group <name> via GET /groups?search=<name> (exact match on
+ * `full_path` or `name`), then POSTs /projects with { name, path, namespace_id }.
+ * Finally runs `git init / add / commit / remote add / push -u origin <branch>`.
+ *
+ * Environment / flags:
+ *   --base-url  <url>    (e.g. https://gitlab.finam.ru/api/v4) — required
+ *   --token     <tok>    GitLab private token — required
+ *   --group     <name>   Group name or full path (e.g. "mcp-servers") — required unless --group-id is given
+ *   --group-id  <n>      Numeric group id — overrides --group lookup
+ *   --name      <name>   Project name — required
+ *   --path      <slug>   URL slug (kebab-case). Defaults to --name lowercased / slugified
+ *   --cwd       <dir>    Directory to push. Defaults to process.cwd()
+ *   --branch    <name>   Branch to push. Defaults to "main"
+ *   --visibility <v>     private|internal|public (default: private)
+ *   --dry-run            Print what would happen, don't call API or git
+ *
+ * ENV fallbacks: GITLAB_BASE_URL, GITLAB_TOKEN, GITLAB_GROUP, GITLAB_GROUP_ID.
+ */
+
+import https from 'https';
+import http from 'http';
+import { URL } from 'url';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+function getOpt (flag) {
+  const i = process.argv.indexOf(flag);
+  return i >= 0 ? process.argv[i + 1] : undefined;
+}
+function hasFlag (flag) {
+  return process.argv.includes(flag);
+}
+
+const baseUrl  = getOpt('--base-url')  || process.env.GITLAB_BASE_URL;
+const token    = getOpt('--token')     || process.env.GITLAB_TOKEN;
+let   groupArg = getOpt('--group')     || process.env.GITLAB_GROUP;
+let   groupId  = getOpt('--group-id')  || process.env.GITLAB_GROUP_ID;
+const projectName = getOpt('--name');
+const projectPath = getOpt('--path') || (projectName
+  ? projectName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '')
+  : undefined);
+const cwd    = path.resolve(getOpt('--cwd') || process.cwd());
+const branch = getOpt('--branch') || 'main';
+const visibility = getOpt('--visibility') || 'private';
+const dryRun = hasFlag('--dry-run');
+
+function die (msg, code = 1) {
+  console.error(`ERROR: ${msg}`);
+  process.exit(code);
+}
+
+if (!baseUrl)     die('Missing --base-url (or GITLAB_BASE_URL). Example: https://gitlab.finam.ru/api/v4');
+if (!token)       die('Missing --token (or GITLAB_TOKEN).');
+if (!projectName) die('Missing --name (project name).');
+if (!groupId && !groupArg) die('Missing --group or --group-id.');
+
+function request (method, url, bodyObj) {
+  const u = new URL(url);
+  const lib = u.protocol === 'http:' ? http : https;
+  const body = bodyObj ? JSON.stringify(bodyObj) : null;
+  const opts = {
+    method,
+    hostname: u.hostname,
+    port: u.port || (u.protocol === 'http:' ? 80 : 443),
+    path: u.pathname + u.search,
+    headers: {
+      'PRIVATE-TOKEN': token,
+      'Accept': 'application/json',
+      ...(body ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } : {}),
+    },
+  };
+  return new Promise((resolve, reject) => {
+    const req = lib.request(opts, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        let json;
+        try { json = text ? JSON.parse(text) : {}; } catch { json = { raw: text }; }
+        if (res.statusCode >= 200 && res.statusCode < 300) resolve(json);
+        else reject(new Error(`HTTP ${res.statusCode} ${u.pathname}: ${text}`));
+      });
+    });
+    req.on('error', reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+function sh (cmd, opts = {}) {
+  console.log(`  $ ${cmd}`);
+  if (dryRun) return '';
+  return execSync(cmd, { stdio: ['ignore', 'pipe', 'pipe'], cwd, ...opts }).toString().trim();
+}
+
+async function resolveGroupId () {
+  if (groupId) return Number(groupId);
+  console.log(`[gitlab] Looking up group "${groupArg}" …`);
+  const url = `${baseUrl.replace(/\/$/, '')}/groups?search=${encodeURIComponent(groupArg)}&per_page=100`;
+  if (dryRun) return 0;
+  const res = await request('GET', url);
+  if (!Array.isArray(res) || res.length === 0) die(`No groups found matching "${groupArg}".`);
+  const exact = res.find((g) => g.full_path === groupArg || g.path === groupArg || g.name === groupArg);
+  const pick = exact || res[0];
+  console.log(`[gitlab] group: ${pick.full_path} (id=${pick.id})`);
+  return pick.id;
+}
+
+async function createProject (namespaceId) {
+  console.log(`[gitlab] Creating project "${projectName}" (path=${projectPath}) in namespace ${namespaceId} …`);
+  const url = `${baseUrl.replace(/\/$/, '')}/projects`;
+  if (dryRun) return { ssh_url_to_repo: 'git@example:stub.git', http_url_to_repo: 'https://example/stub.git', web_url: 'https://example/stub' };
+  const body = {
+    name: projectName,
+    path: projectPath,
+    namespace_id: namespaceId,
+    visibility,
+    initialize_with_readme: false,
+  };
+  const res = await request('POST', url, body);
+  console.log(`[gitlab] created: ${res.web_url}`);
+  return res;
+}
+
+function gitPush (remoteUrl) {
+  console.log(`[git] Initializing and pushing ${cwd} to ${remoteUrl} …`);
+  if (!fs.existsSync(path.join(cwd, '.git'))) sh('git init');
+  sh(`git checkout -B ${branch}`);
+  sh('git add -A');
+  try {
+    sh('git diff --cached --quiet');
+    console.log('[git] Nothing to commit — working tree already clean.');
+  } catch {
+    sh('git commit -m "Initial commit (scaffolded by fa-mcp)"');
+  }
+  try { sh('git remote remove origin'); } catch { /* no origin yet */ }
+  sh(`git remote add origin ${remoteUrl}`);
+  sh(`git push -u origin ${branch}`);
+}
+
+(async () => {
+  try {
+    const nsId = await resolveGroupId();
+    const project = await createProject(nsId);
+    const remote = project.ssh_url_to_repo || project.http_url_to_repo;
+    if (!remote) die('GitLab did not return a repo URL.');
+    gitPush(remote);
+    console.log(`\nDone. ${project.web_url || remote}`);
+  } catch (e) {
+    die(e.message);
+  }
+})();

package/cli-template/.claude/skills/deploy-mcp/scripts/headless-chat.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+/**
+ * Multi-turn wrapper around POST /agent-tester/api/chat/test. Sends a sequence of user messages
+ * in a single server-side session so the agent retains dialog history across questions.
+ *
+ * Input: a plain text file, one message per non-empty line. Lines starting with '#' are ignored.
+ *
+ * Usage:
+ *   node headless-chat.js --port 9876 --messages scenarios.txt [options]
+ *
+ * Options:
+ *   --port <n>             Web server port (required)
+ *   --messages <path>      Text file, one user message per line (required)
+ *   --auth <header>        Full Authorization header value. Optional.
+ *   --verbose              Include per-turn LLM request/response in trace
+ *   --max-result <n>       Max chars per tool result (default 4000)
+ *   --max-trace <n>        Max total trace size (default 50000)
+ *   --agent-prompt <s>     Override system prompt (applied to the whole dialog)
+ *   --model <name>         Model name (default: let server choose)
+ *   --timeout <ms>         Request timeout per message (default 120000)
+ *   --session <id>         Start from an existing sessionId instead of a fresh one
+ *   --session-file <path>  Persist final sessionId (same semantics as headless-test.js)
+ *   --stop-on-error        Abort the sequence on first non-2xx response (default: continue)
+ *   --out <path>           Write an aggregated JSON array of per-turn responses to this file
+ *
+ * Each response is also printed to stdout as a JSON object prefixed by a header line
+ *   === MESSAGE <n>/<total>: <first-80-chars> ===
+ * Exit code: 0 if all messages returned 2xx, 1 otherwise.
+ */
+
+import fs from 'fs';
+import http from 'http';
+
+function getOpt (flag, fallback) {
+  const i = process.argv.indexOf(flag);
+  return i >= 0 ? process.argv[i + 1] : fallback;
+}
+
+function hasFlag (flag) { return process.argv.includes(flag); }
+
+const port = getOpt('--port');
+const messagesArg = getOpt('--messages');
+const auth = getOpt('--auth');
+const verbose = hasFlag('--verbose');
+const maxResult = getOpt('--max-result', '4000');
+const maxTrace = getOpt('--max-trace', '50000');
+const agentPrompt = getOpt('--agent-prompt');
+const model = getOpt('--model');
+const timeout = Number(getOpt('--timeout', '120000'));
+const sessionOpt = getOpt('--session');
+const sessionFile = getOpt('--session-file');
+const stopOnError = hasFlag('--stop-on-error');
+const outPath = getOpt('--out');
+
+if (!port || !messagesArg) {
+  console.error('Usage: headless-chat.js --port <n> --messages <file> [--session-file <path>] [--verbose]');
+  process.exit(2);
+}
+
+const raw = fs.readFileSync(messagesArg, 'utf8');
+const messages = raw.split(/\r?\n/).map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+if (messages.length === 0) {
+  console.error(`no messages found in ${messagesArg}`);
+  process.exit(2);
+}
+
+let sessionId = sessionOpt;
+if (!sessionId && sessionFile) {
+  try {
+    const s = fs.readFileSync(sessionFile, 'utf8').trim();
+    if (s) sessionId = s;
+  } catch (e) {
+    if (e.code !== 'ENOENT') {
+      console.error(`session-file read error: ${e.message}`);
+      process.exit(2);
+    }
+  }
+}
+
+function sendOne (message) {
+  return new Promise((resolve, reject) => {
+    const body = {
+      message,
+      mcpConfig: { url: `http://localhost:${port}/mcp`, transport: 'http' },
+    };
+    if (sessionId) body.sessionId = sessionId;
+    if (auth) body.mcpConfig.headers = { Authorization: auth };
+    if (agentPrompt) body.agentPrompt = agentPrompt;
+    if (model) body.modelConfig = { model };
+
+    const payload = JSON.stringify(body);
+    const qs = `?verbose=${verbose}&maxResultChars=${maxResult}&maxTraceChars=${maxTrace}`;
+
+    const req = http.request({
+      hostname: 'localhost',
+      port,
+      path: `/agent-tester/api/chat/test${qs}`,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+        ...(auth ? { Authorization: auth } : {}),
+      },
+      timeout,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        let parsed = null;
+        try { parsed = JSON.parse(text); } catch { /* keep raw */ }
+        resolve({ status: res.statusCode, text, parsed });
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(new Error('timeout')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+(async () => {
+  const results = [];
+  let anyFailure = false;
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const header = `=== MESSAGE ${i + 1}/${messages.length}: ${msg.slice(0, 80)} ===`;
+    process.stdout.write(header + '\n');
+
+    let result;
+    try {
+      result = await sendOne(msg);
+    } catch (e) {
+      anyFailure = true;
+      process.stdout.write(`request error: ${e.message}\n`);
+      results.push({ message: msg, error: e.message });
+      if (stopOnError) break;
+      continue;
+    }
+
+    process.stdout.write(result.text + '\n');
+
+    if (result.parsed?.sessionId) sessionId = result.parsed.sessionId;
+    const ok = result.status >= 200 && result.status < 300;
+    if (!ok) anyFailure = true;
+
+    results.push({
+      message: msg,
+      status: result.status,
+      response: result.parsed ?? result.text,
+    });
+
+    if (!ok && stopOnError) break;
+  }
+
+  if (sessionFile && sessionId) {
+    try { fs.writeFileSync(sessionFile, sessionId); } catch (e) { console.error(`session-file write skipped: ${e.message}`); }
+  }
+
+  if (outPath) {
+    try { fs.writeFileSync(outPath, JSON.stringify(results, null, 2)); } catch (e) { console.error(`out write failed: ${e.message}`); }
+  }
+
+  process.exit(anyFailure ? 1 : 0);
+})();

package/cli-template/.claude/skills/deploy-mcp/scripts/headless-test.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Thin wrapper around POST /agent-tester/api/chat/test — used by the deploy-mcp skill
+ * to exercise the freshly-built MCP server through the full agent loop.
+ *
+ * Usage:
+ *   node headless-test.js --port 9876 --message "What is the EUR/USD rate?" [options]
+ *
+ * Options:
+ *   --port <n>             Web server port (required)
+ *   --message <text>       User message to send (required)
+ *   --auth <header>        Full Authorization header value (e.g. "Bearer xxxx"). Optional.
+ *   --verbose              Include per-turn LLM request/response in trace
+ *   --max-result <n>       Max chars per tool result (default 4000)
+ *   --max-trace <n>        Max total trace size (default 50000)
+ *   --agent-prompt <s>     Override system prompt for this request
+ *   --model <name>         Model name (default: let server choose)
+ *   --timeout <ms>         Request timeout (default 120000)
+ *   --session <id>         Reuse existing server-side dialog history under this sessionId
+ *   --session-file <path>  Persist sessionId in a file: read if exists, write back after response.
+ *                          Chains multiple invocations into one conversation without manual parsing.
+ *                          If both --session and --session-file are given, --session wins for the
+ *                          request; the final sessionId is still written to the file.
+ *
+ * Prints the JSON response to stdout. Exit code 0 on 2xx, non-zero otherwise.
+ */
+
+import fs from 'fs';
+import http from 'http';
+
+function getOpt (flag, fallback) {
+  const i = process.argv.indexOf(flag);
+  return i >= 0 ? process.argv[i + 1] : fallback;
+}
+function hasFlag (flag) { return process.argv.includes(flag); }
+
+const port    = getOpt('--port');
+const message = getOpt('--message');
+const auth    = getOpt('--auth');
+const verbose = hasFlag('--verbose');
+const maxResult = getOpt('--max-result', '4000');
+const maxTrace  = getOpt('--max-trace', '50000');
+const agentPrompt = getOpt('--agent-prompt');
+const model   = getOpt('--model');
+const timeout = Number(getOpt('--timeout', '120000'));
+const sessionOpt  = getOpt('--session');
+const sessionFile = getOpt('--session-file');
+
+if (!port || !message) {
+  console.error('Usage: headless-test.js --port <n> --message "<text>" [--auth "Bearer ..."] [--verbose] [--model <name>] [--session <id>] [--session-file <path>]');
+  process.exit(2);
+}
+
+let sessionId = sessionOpt;
+if (!sessionId && sessionFile) {
+  try {
+    const raw = fs.readFileSync(sessionFile, 'utf8').trim();
+    if (raw) sessionId = raw;
+  } catch (e) {
+    if (e.code !== 'ENOENT') {
+      console.error(`session-file read error: ${e.message}`);
+      process.exit(2);
+    }
+  }
+}
+
+const body = {
+  message,
+  mcpConfig: { url: `http://localhost:${port}/mcp`, transport: 'http' },
+};
+if (sessionId) body.sessionId = sessionId;
+if (auth) body.mcpConfig.headers = { Authorization: auth };
+if (agentPrompt) body.agentPrompt = agentPrompt;
+if (model) body.modelConfig = { model };
+
+const qs = `?verbose=${verbose}&maxResultChars=${maxResult}&maxTraceChars=${maxTrace}`;
+const payload = JSON.stringify(body);
+
+const req = http.request({
+  hostname: 'localhost',
+  port,
+  path: `/agent-tester/api/chat/test${qs}`,
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(payload),
+    ...(auth ? { Authorization: auth } : {}),
+  },
+  timeout,
+}, (res) => {
+  const chunks = [];
+  res.on('data', (c) => chunks.push(c));
+  res.on('end', () => {
+    const text = Buffer.concat(chunks).toString('utf8');
+    process.stdout.write(text);
+    if (sessionFile && res.statusCode >= 200 && res.statusCode < 300) {
+      try {
+        const parsed = JSON.parse(text);
+        if (parsed?.sessionId) fs.writeFileSync(sessionFile, parsed.sessionId);
+      } catch (e) {
+        console.error(`session-file write skipped: ${e.message}`);
+      }
+    }
+    process.exit(res.statusCode >= 200 && res.statusCode < 300 ? 0 : 1);
+  });
+});
+req.on('error', (e) => { console.error(`request error: ${e.message}`); process.exit(1); });
+req.on('timeout', () => { req.destroy(new Error('timeout')); });
+req.write(payload);
+req.end();

package/cli-template/.claude/skills/readme-generator/reference/satellite-templates.md

@@ -354,7 +354,7 @@ Priority: env vars > `config/local.yaml` > `config/{NODE_ENV}.yaml` > `config/de
 
 | Key                                   | Description                             | Default   |
 |---------------------------------------|-----------------------------------------|-----------|
-| `mcp.toolAnswerAs`                    | Response format (`text` / `json`)       | `text`    |
+| `mcp.tools.answerAs`                  | Response format (`text` / `json`)       | `text`    |
 | `mcp.name`                            | Name returned to MCP clients            | —         |
 
 ## Upstream `<prefix>`

package/cli-template/.claude/skills/readme-generator/reference/templates.md

@@ -339,7 +339,7 @@ Priority: env vars > `config/local.yaml` > `config/{NODE_ENV}.yaml` > `config/de
 | `<upstream>.auth.basic.password` | Basic auth password                 | —         |
 | `webServer.port`                 | HTTP server port                    | `<PORT>`  |
 | `webServer.auth.enabled`         | MCP server authorization on/off     | `false`   |
-| `mcp.toolAnswerAs`               | Response format (`text` / `json`)   | `text`    |
+| `mcp.tools.answerAs`             | Response format (`text` / `json`)   | `text`    |
 
 Full reference: [Configuration](./readme-docs/configuration.md).
 ```

package/cli-template/FA-MCP-SDK-DOC/01-getting-started.md

@@ -121,7 +121,7 @@ const dbEnabled = appConfig.isMainDBUsed;
 | `shortName` | Name without 'mcp' suffix |
 | `version` | Package version |
 | `webServer` | HTTP server config (host, port, auth) |
-| `mcp` | MCP settings (transportType, rateLimit, tools.hideAnnotations) |
+| `mcp` | MCP settings (transportType, rateLimit, tools.answerAs, tools.hideAnnotations) |
 | `logger` | Logging config |
 | `ad` | Active Directory config |
 | `consul` | Service discovery settings |

package/cli-template/FA-MCP-SDK-DOC/03-configuration.md

@@ -109,11 +109,11 @@ logger:
 
 mcp:
   transportType: http  # stdio | http
-  toolAnswerAs: text   # text | structuredContent
   rateLimit:
     maxRequests: 100
     windowMs: 60000
   tools:
+    answerAs: text   # text | structuredContent
     hideAnnotations: false  # true — strip `annotations` from tool listings
 
 swagger:

package/cli-template/FA-MCP-SDK-DOC/06-utilities.md

@@ -80,21 +80,21 @@ import { getTools, formatToolResult, getJsonFromResult, asTextContent, asJson }
 
 const tools = await getTools();  // Get registered tools
 
-// Format based on appConfig.mcp.toolAnswerAs
+// Format based on appConfig.mcp.tools.answerAs
 const result = formatToolResult({ message: 'Done', data: {} });
 
-// Returns structuredContent or JSON from text depending on appConfig.mcp.toolAnswerAs
+// Returns structuredContent or JSON from text depending on appConfig.mcp.tools.answerAs
 const original = getJsonFromResult<T>(result);
 
-// Direct formatting helpers (ignore toolAnswerAs config):
+// Direct formatting helpers (ignore tools.answerAs config):
 asTextContent('Hello');           // { content: [{ type: 'text', text: 'Hello' }] }
 asJson({ status: 'ok' });         // { structuredContent: { status: 'ok' } }
 ```
 
 ### When to Use Which
 
-- **`formatToolResult()`** — Primary choice in tool handlers. Respects `appConfig.mcp.toolAnswerAs` config.
-- **`asTextContent()` / `asJson()`** — Direct formatting, ignores `toolAnswerAs`. Use when specific format needed.
+- **`formatToolResult()`** — Primary choice in tool handlers. Respects `appConfig.mcp.tools.answerAs` config.
+- **`asTextContent()` / `asJson()`** — Direct formatting, ignores `tools.answerAs`. Use when specific format needed.
 - **`getJsonFromResult()`** — Inverse of `formatToolResult()`. Extracts JSON from either format. Use in tests.
 
 ## Network Utilities

package/cli-template/package.json

@@ -50,7 +50,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "dotenv": "^17.4.1",
-    "fa-mcp-sdk": "^0.4.60"
+    "fa-mcp-sdk": "^0.4.64"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",

package/cli-template/readme-docs/SKILLS.md

@@ -137,3 +137,52 @@ Characteristics:
 /readme-generator refresh the README after adding 3 new tools
 /readme-generator обнови README с учётом того, что теперь подключён PostgreSQL
 ```
+
+---
+
+### `/deploy-mcp` — End-to-End MCP Server Implementation
+
+Orchestrates the full implementation workflow from feature brief to a live GitLab repo. The project
+must already be scaffolded by the `fa-mcp` CLI — this skill picks up from `yarn install` onwards.
+
+Pipeline (10 steps):
+
+1. **Requirements scan** — extracts tools, source-of-truth refs, exclusions, and OpenAI creds from
+   accompanying messages/files
+2. **OpenAI pre-flight** — `scripts/check-openai.js` validates the key against `GET /v1/models`
+   before anything touches `config/local.yaml`
+3. **Dev secrets** — `scripts/gen-secrets.js` writes fresh `jwtToken.encryptKey`,
+   `permanentServerTokens`, OpenAI creds, and lenient dev defaults into `config/local.yaml`
+4. **Install & build** — `yarn install` + `yarn cb`
+5. **First GitLab push** — ensures branch is clean (stashing what shouldn't ship), commits the
+   scaffold, then either creates a new GitLab repo via `scripts/gitlab-push.js` OR pushes to an
+   existing remote when instructed (text says "don't create" / `origin` is already configured)
+6. **Plan** — writes `claudedocs/impl-plan.md` with tools / resources / prompts / REST / config /
+   tests / Agent Tester scenarios / sign-off checklist
+7. **Implementation** — edits `src/tools/*`, `src/prompts/*`, `src/custom-resources.ts`,
+   `src/api/router.ts`, `config/default.yaml`, `tests/mcp/test-cases.js`; rebuilds after each change
+8. **Agent Tester loop** — `yarn check-llm` → `yarn start` → `scripts/headless-test.js` /
+   `scripts/headless-chat.js` against `/agent-tester/api/chat/test`; logs in `claudedocs/test-log.md`
+9. **Quality gates** — `yarn lint:fix`, `yarn typecheck`, `yarn cb`, `yarn test:mcp[-http|-sse]`
+10. **Second GitLab push** — commits implemented feature and `git push origin main` to the remote
+    set up in step 5 (no re-creation, never `--force` without explicit approval)
+
+Characteristics:
+
+- **Launch**: **command-only** via `/deploy-mcp`. `disable-model-invocation: true` — does NOT
+  trigger on implicit mentions
+- **Input**: feature brief comes from the accompanying user message(s) and attached files. OpenAI
+  and GitLab creds may be supplied inline or asked interactively
+- **Ground rules**: every step explicit and verified; free-form inputs asked in plain prose (never
+  predefined options); exclusions from the brief honoured; dev defaults intentionally lenient;
+  `.claude/`, `deploy/`, `FA-MCP-SDK-DOC/` are NOT modified unless the brief explicitly says to
+- **Output**: implemented project + `claudedocs/{impl-plan,test-log,dev-report}.md`, GitLab repo
+  with two commits on `main` (scaffold + feature)
+
+**Examples:**
+
+```
+/deploy-mcp
+/deploy-mcp реализуй инструменты из task.md, OpenAI key sk-..., GitLab group mcp-servers
+/deploy-mcp implement tools from the message; repo уже существует, push to git@gitlab.example:ai/mcp-foo.git
+```

package/cli-template/tsconfig.json

@@ -35,15 +35,22 @@
   "exclude": [
     ".claude",
     ".idea",
+    ".junie",
+    ".playwright-mcp",
     ".run",
+    ".serena",
     "_misc",
     "_tmp",
     "config",
+    "out",
     "deploy",
     "dist",
     "doc",
+    "docs",
     "node_modules",
-    "coverage"
+    "out",
+    "coverage",
+    "swagger"
   ],
   "ts-node": {
     "esm": true

package/config/_local.yaml

@@ -217,18 +217,18 @@ logger:
 mcp:
   #> Transport for the MCP server: stdio | http
   transportType: http
-  #> Response format configuration.
-  #> - structuredContent — default — the response in result.structuredContent returns JSON
-  #> - text — in the response, serialized JSON is returned in result.content[0].text
-  toolAnswerAs: text
   #> Per-client request rate limiting for the MCP endpoint
   rateLimit:
     #> Maximum number of requests allowed within windowMs
     maxRequests: 100
     #> Rate limit window length in milliseconds (1 minute)
     windowMs: 60000
-  #> Tool listing behavior
+  #> Tool listing and response behavior
   tools:
+    #> Response format configuration.
+    #> - structuredContent — default — the response in result.structuredContent returns JSON
+    #> - text — in the response, serialized JSON is returned in result.content[0].text
+    answerAs: text
     #> When true, strips `annotations` from tool listings returned to clients
     #> (hides hints like readOnlyHint / destructiveHint). Default: false.
     hideAnnotations: false

package/config/custom-environment-variables.yaml

@@ -34,11 +34,11 @@ logger:
 
 mcp:
   transportType: MCP_TRANSPORT_TYPE
-  toolAnswerAs: MCP_TOOL_ANSWER_AS
   rateLimit:
     maxRequests: MCP_RATE_LIMIT_MAX_REQUESTS
     windowMs: MCP_RATE_LIMIT_WINDOW_MS
   tools:
+    answerAs: MCP_TOOLS_ANSWER_AS
     hideAnnotations: MCP_TOOLS_HIDE_ANNOTATIONS
 
 uiColor:

package/config/default.yaml

@@ -235,18 +235,18 @@ logger:
 mcp:
   #> Transport for the MCP server: stdio | http
   transportType: http
-  #> Response format configuration.
-  #> - structuredContent — default — the response in result.structuredContent returns JSON
-  #> - text — in the response, serialized JSON is returned in result.content[0].text
-  toolAnswerAs: text
   #> Per-client request rate limiting for the MCP endpoint
   rateLimit:
     #> Maximum number of requests allowed within windowMs
     maxRequests: 100
     #> Rate limit window length in milliseconds (1 minute)
     windowMs: 60000
-  #> Tool listing behavior
+  #> Tool listing and response behavior
   tools:
+    #> Response format configuration.
+    #> - structuredContent — default — the response in result.structuredContent returns JSON
+    #> - text — in the response, serialized JSON is returned in result.content[0].text
+    answerAs: text
     #> When true, strips `annotations` from tool listings returned to clients
     #> (hides hints like readOnlyHint / destructiveHint). Default: false.
     hideAnnotations: false