hac-mcp 1.0.0

package/tools/run_cronjob.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { groovyExecute } from '../hac.js';
+import { withSession, getEnvironment, mcpLogStart, mcpLog, text, error } from './context.js';
+
+const TOOL = 'run_cronjob';
+
+const SCRIPT = (cronJobPk) => `
+import de.hybris.platform.core.PK
+
+def cronJobService = spring.getBean('cronJobService')
+def modelService = spring.getBean('modelService')
+
+def cronJob = modelService.get(PK.fromLong(${cronJobPk}L))
+cronJobService.performCronJob(cronJob, true)
+
+modelService.refresh(cronJob)
+def status = cronJob.status?.code
+def result = cronJob.result?.code
+def startTime = cronJob.startTime
+def endTime = cronJob.endTime
+"status=\${status}, result=\${result}, startTime=\${startTime}, endTime=\${endTime}"
+`.trim();
+
+export const tool = {
+  name: TOOL,
+  category: 'write',
+  description: 'Run a SAP Commerce CronJob synchronously by its PK and wait for it to finish. Returns the final status and result. IMPORTANT: Before calling this tool, you MUST tell the user which CronJob will run and what it does (e.g. sending emails, syncing data, triggering workflows) and explicitly ask for their confirmation. Only proceed after the user approves and set confirmed_by_user to true.',
+  inputSchema: {
+    environmentId: z.string().describe('Environment ID from list_environments'),
+    cronJobPk: z.string().describe('PK of the CronJob to run'),
+    confirmed_by_user: z.boolean().describe('Must be true - user has explicitly reviewed which CronJob will run and approved. The server will reject the call if false.'),
+  },
+  handler: async ({ environmentId, cronJobPk, confirmed_by_user }) => {
+    if (!confirmed_by_user) {
+      return error('User confirmation required. Tell the user which CronJob will run and what it does, ask for explicit approval, then retry with confirmed_by_user: true.');
+    }
+    const env = await getEnvironment(environmentId);
+    if (!env) {
+      mcpLog({ tool: TOOL, envName: environmentId, preview: 'Unknown environment', isError: true });
+      return error(`Environment "${environmentId}" not found.`);
+    }
+    if (!env.allowGroovyExecution) {
+      mcpLog({ tool: TOOL, envName: env.name, preview: 'Groovy disabled', isError: true });
+      return error(`Groovy execution is disabled for environment "${env.name}".`);
+    }
+    if (env.allowGroovyCommitMode === false) {
+      mcpLog({ tool: TOOL, envName: env.name, preview: 'Groovy commit mode disabled', isError: true });
+      return error(`Groovy commit mode is disabled for environment "${env.name}".`);
+    }
+
+    const runId = mcpLogStart({ tool: TOOL, envName: env.name, preview: `Running CronJob PK ${cronJobPk}` });
+
+    let result;
+    try {
+      result = await withSession(env, s => groovyExecute(s, SCRIPT(cronJobPk), { commit: true }));
+    } catch (e) {
+      mcpLog({ tool: TOOL, envName: env.name, preview: `Error: ${e.message}`, detail: e.stack || '', isError: true, runId });
+      return error(e.message);
+    }
+
+    const isErr = !!result.stacktraceText;
+    const preview = isErr ? `❌ CronJob PK ${cronJobPk}` : `✅ ${result.executionResult}`;
+    mcpLog({ tool: TOOL, envName: env.name, preview, detail: result.stacktraceText || '', isError: isErr, runId });
+
+    let out = `**${env.name}** - ${isErr ? '❌ Error' : '✅ CronJob finished'}\n`;
+    if (result.executionResult) out += `\n**Result:**\n\`\`\`\n${result.executionResult}\n\`\`\``;
+    if (result.outputText) out += `\n**Output:**\n\`\`\`\n${result.outputText}\n\`\`\``;
+    if (result.stacktraceText) out += `\n**Stacktrace:**\n\`\`\`\n${result.stacktraceText}\n\`\`\``;
+    return isErr ? { content: [{ type: 'text', text: out }], isError: true } : text(out);
+  },
+};

package/tools/search_type.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { getEnvironment, getTypeIndex, fuzzySearch, mcpLogStart, mcpLog, text, error } from './context.js';
+
+const TOOL = 'search_type';
+
+export const tool = {
+  name: TOOL,
+  category: 'read',
+  description: 'Search for SAP Commerce type names by fuzzy match. Use this before get_type_info when you are unsure of the exact type code.',
+  inputSchema: {
+    environmentId: z.string().describe('Environment ID from list_environments'),
+    query: z.string().describe('Type name to search for - fuzzy, e.g. "InboundProductLogs", "Solr", "Order"'),
+  },
+  handler: async ({ environmentId, query }) => {
+    const env = await getEnvironment(environmentId);
+    if (!env) {
+      mcpLog({ tool: TOOL, envName: environmentId, preview: 'Unknown environment', isError: true });
+      return error(`Environment "${environmentId}" not found.`);
+    }
+
+    const runId = mcpLogStart({ tool: TOOL, envName: env.name, preview: `Searching "${query}"…` });
+
+    let types;
+    try {
+      types = await getTypeIndex(env);
+    } catch (e) {
+      mcpLog({ tool: TOOL, envName: env.name, preview: `Error: ${e.message}`, isError: true, runId });
+      return error(`Failed to load type index: ${e.message}`);
+    }
+
+    const matches = fuzzySearch(query, types, { topN: 20 });
+    if (!matches.length) {
+      mcpLog({ tool: TOOL, envName: env.name, preview: `No types for "${query}"`, runId });
+      return text(`No types found matching "${query}".`);
+    }
+
+    mcpLog({ tool: TOOL, envName: env.name, preview: `${matches.length} type(s) for "${query}"`, detail: matches.join('\n'), runId });
+    return text(`Types matching "${query}":\n${matches.join('\n')}`);
+  },
+};

package/tools/zodLoose.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+export function optionalLooseNumber() {
+  return z.preprocess((val) => {
+    if (val === undefined || val === null) return undefined;
+    if (typeof val === 'number') return val;
+    if (typeof val === 'string' && val.trim() !== '') {
+      const n = Number(val);
+      if (!isNaN(n)) return n;
+    }
+    return val;
+  }, z.number().optional());
+}
+
+export function optionalLooseBool() {
+  return z.preprocess((val) => {
+    if (val === undefined || val === null) return undefined;
+    if (typeof val === 'boolean') return val;
+    if (typeof val === 'string') {
+      const t = val.trim().toLowerCase();
+      if (t === 'true' || t === '1' || t === 'yes') return true;
+      if (t === 'false' || t === '0' || t === 'no') return false;
+    }
+    return val;
+  }, z.boolean().optional());
+}

package/type-index.js

@@ -0,0 +1,92 @@
+// ─── Per-environment ComposedType index with trigram fuzzy search ─────────────
+//
+// Trigram similarity (PostgreSQL-style):
+//   score = |intersection(trigrams(a), trigrams(b))| / |union(trigrams(a), trigrams(b))|
+// Plus a bonus for exact substring containment so "Order" still ranks OrderEntry high.
+
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+// envId → { types: string[], fetchedAt: number, promise?: Promise }
+const cache = new Map();
+
+// ─── Trigram helpers ──────────────────────────────────────────────────────────
+function trigrams(str) {
+  // Pad with two spaces on each side (standard PostgreSQL padding)
+  const s = `  ${str.toLowerCase()}  `;
+  const set = new Set();
+  for (let i = 0; i < s.length - 2; i++) set.add(s.slice(i, i + 3));
+  return set;
+}
+
+function trigramSimilarity(a, b) {
+  const ta = trigrams(a);
+  const tb = trigrams(b);
+  let inter = 0;
+  for (const t of ta) if (tb.has(t)) inter++;
+  const union = ta.size + tb.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+
+// ─── Scoring: trigram + substring bonus ──────────────────────────────────────
+function score(query, candidate) {
+  const q = query.toLowerCase();
+  const c = candidate.toLowerCase();
+  let s = trigramSimilarity(q, c);
+  // Exact substring match bonus (like LIKE '%q%' but boosted)
+  if (c.includes(q)) s += 0.3;
+  // Prefix match bonus
+  if (c.startsWith(q)) s += 0.2;
+  return s;
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Populate (or refresh) the index for an environment.
+ * flexSearchFn: (query, opts?) => Promise<{ resultList, exception }>
+ */
+export async function refreshIndex(envId, flexSearchFn) {
+  const result = await flexSearchFn(
+    `SELECT {code} FROM {ComposedType} ORDER BY {code} ASC`,
+    { maxCount: 5000 }
+  );
+  if (result.exception) throw new Error(result.exception.message || JSON.stringify(result.exception));
+  const types = (result.resultList || []).map(([code]) => code);
+  cache.set(envId, { types, fetchedAt: Date.now() });
+  return types;
+}
+
+/**
+ * Get the cached index, fetching if missing or stale.
+ * flexSearchFn: bound to the env's session
+ */
+export async function getIndex(envId, flexSearchFn) {
+  const entry = cache.get(envId);
+  if (entry && !entry.promise && Date.now() - entry.fetchedAt < CACHE_TTL_MS) {
+    return entry.types;
+  }
+  // Deduplicate concurrent fetches
+  if (entry?.promise) return entry.promise;
+  const promise = refreshIndex(envId, flexSearchFn)
+    .finally(() => { if (cache.get(envId)?.promise) delete cache.get(envId).promise; });
+  cache.set(envId, { ...(entry || { types: [], fetchedAt: 0 }), promise });
+  return promise;
+}
+
+/** Invalidate an env's cache (call after schema changes or on demand). */
+export function invalidateIndex(envId) {
+  cache.delete(envId);
+}
+
+/**
+ * Fuzzy search the index.
+ * Returns up to `topN` results with score > threshold, sorted by score desc.
+ */
+export function fuzzySearch(query, types, { topN = 20, threshold = 0.1 } = {}) {
+  const scored = types
+    .map(t => ({ type: t, score: score(query, t) }))
+    .filter(x => x.score > threshold)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, topN);
+  return scored.map(x => x.type);
+}