@sassoftware/sas-score-mcp-serverjs 0.4.1-21 → 0.4.1-24

package/scripts/setup-skills.js

@@ -1,78 +1,32 @@
 #!/usr/bin/env node
-
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { parseArgs } from "node:util";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Recursive copy function
-function copyRecursiveSync(src, dest) {
-  const stat = fs.statSync(src);
-  
-  if (stat.isDirectory()) {
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true });
-    }
-    const files = fs.readdirSync(src);
-    files.forEach(file => {
-      copyRecursiveSync(path.join(src, file), path.join(dest, file));
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Paths
+let client = (process.env.CLIENTNAME == null) ? '.github' : `.${process.env.CLIENTNAME.toLowerCase()}`;
+const source = path.join(__dirname, `.skills`);
+const destination = path.join(process.cwd(), client);
+console.error(`📁 Copying ${source} to ${destination}...`);
+function copyFolderSync(from, to) {
+    if (!fs.existsSync(from)) return;
+    if (!fs.existsSync(to)) fs.mkdirSync(to, { recursive: true });
+    console.error(`📁 Copying folder: ${from} to ${to}`);
+    fs.readdirSync(from).forEach(element => {
+        const fromPath = path.join(from, element);
+        const toPath = path.join(to, element);
+        if (fs.lstatSync(fromPath).isFile()) {
+            fs.copyFileSync(fromPath, toPath);
+        } else if (fs.lstatSync(fromPath).isDirectory()) {
+            copyFolderSync(fromPath, toPath);
+        }
     });
-  } else {
-    fs.copyFileSync(src, dest);
-  }
-}
-
-// Get folder name from command line arguments or environment variable
-const args = parseArgs({
-  options: {
-    'skills-folder': {
-      type: 'string',
-      short: 'f',
-      description: 'Skills folder name'
-    }
-  }});
-
-let folderName = args.values['skills-folder'] || process.env.SKILLS_FOLDER_NAME;
-if (folderName == null) {
-  folderName = '.github';
-}
-folderName = folderName + '/skills';
-// If no folder name provided, show usage
-if (!folderName) {
-  console.error('Usage:');
-  console.error('  npm run setup-skills -f <folder-name>');
-  console.error('  or set SKILLS_FOLDER_NAME environment variable');
-  console.error('\nExample:');
-  console.error('  npm run setup-skills -f my-skills-folder');
-  process.exit(0);
-}
-console.error(`Setting up skills in folder: ${folderName}`);
-// Resolve paths
-const skillsSourcePath = path.join(__dirname, '../skills');
-const targetPath = path.join(process.cwd(), folderName);
-
-// Check if skills folder exists
-if (!fs.existsSync(skillsSourcePath)) {
-  console.error(`Error: Skills folder not found at ${skillsSourcePath}`);
-  process.exit(1);
 }
 
 try {
-  // Create target directory if it doesn't exist
-  if (!fs.existsSync(targetPath)) {
-    fs.mkdirSync(targetPath, { recursive: true });
-    console.error(`✓ Created folder: ${targetPath}`);
-  } else {
-    console.error(`✓ Folder already exists: ${targetPath}`);
-  }
-
-  // Copy skills folder contents to target
-  copyRecursiveSync(skillsSourcePath, targetPath);
-  console.error(`✓ Successfully copied skills to: ${targetPath}`);
-} catch (error) {
-  console.error('Error during setup:', error.message);
-  process.exit(1);
+    copyFolderSync(source, destination);
+    console.error(`✅ Success: ${destination} folder is now in your project root.`);
+} catch (err) {
+    console.error('❌ Error copying files:', err.message);
 }
+process.exit(0);

package/src/setupSkills.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+function setupSkills(clientName) {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    // Paths
+    let client = (clientName == null) ? '.github' : `.${clientName.toLowerCase()}`;
+    const source = path.join(__dirname, `../.skills`); 
+    const destination = path.join(os.homedir(), client);
+    console.error(`📁 Copying ${source} to ${destination}...`);
+    function copyFolderSync(from, to) {
+        if (!fs.existsSync(from)) return;
+        if (!fs.existsSync(to)) fs.mkdirSync(to, { recursive: true });
+        console.error(`📁 Copying folder: ${from} to ${to}`);
+        fs.readdirSync(from).forEach(element => {
+            console.error(`📁 Processing: ${element}`);
+            const fromPath = path.join(from, element);
+            const toPath = path.join(to, element);
+            if (fs.lstatSync(fromPath).isFile()) {
+                fs.copyFileSync(fromPath, toPath);
+            } else if (fs.lstatSync(fromPath).isDirectory()) {
+                copyFolderSync(fromPath, toPath);
+            }
+        });
+    }
+
+    try {
+        copyFolderSync(source, destination);
+        console.error(`✅ Success: ${destination} folder is now in your project root.`);
+    } catch (err) {
+        console.error('❌ Error copying files:', err.message);
+    }
+}
+export default setupSkills;

package/src/toolSet/findModel.js

@@ -9,7 +9,7 @@ import _listModels from '../toolHelpers/_listModels.js';
 
 function findModel(_appContext) {
   let description = `
-find-model — locate a specific model deployed to MAS (Model Aggregation Service).
+find-model — locate a specific MAS model deployed to MAS server 
 
 USE when: find model, does model exist, is model deployed, lookup model, verify model exists
 DO NOT USE for: list models (use list-models), model info/variables (use model-info), score model (use model-score), find table/job/lib (use respective tools), scr models (use scr-info/scr-score)

package/src/toolSet/modelScore.js

@@ -10,7 +10,7 @@ const log = debug('tools');
 
 function modelScore(_appContext) {
   let description = `
-model-score — score data using a deployed model on MAS.
+mas-score — score data using a deployed model on MAS.
 
 USE when: score with model, predict using model, batch scoring, model predictions
 DO NOT USE for: find model, model metadata, list models, run programs/jobs, query tables
@@ -40,7 +40,7 @@ Returns predictions, probabilities, scores merged with input data. Returns error
 
  
   let spec = {
-    name: 'model-score',
+    name: 'mas-score',
     description: description,
     inputSchema:z.object({
       model: z.string(),

package/src/toolSet/runJob.js

@@ -9,9 +9,9 @@ import _jobSubmit from '../toolHelpers/_jobSubmit.js';
 function runJob(_appContext) {
  
   let description = `
-run-job — execute a deployed SAS Viya job.
+run-job — score with a deployed SAS Viya job.
 
-USE when: run job, execute job, run with parameters
+USE when: score with job, run job, execute job
 DO NOT USE for: arbitrary SAS code (use run-sas-program), macros (use run-macro), list/find jobs
 
 PARAMETERS

package/src/toolSet/runJobdef.js

@@ -10,9 +10,9 @@ function runJobdef(_appContext) {
   // JSON object for LLM/tooling
  
   let description = `
-run-jobdef — execute a SAS Viya job definition.
+run-jobdef — score with a deployed SAS Viya job definition.
 
-USE when: run jobdef, execute jobdef, run with parameters
+USE when: score with jobdef, run jobdef, execute jobdef
 DO NOT USE for: arbitrary SAS code (use run-sas-program), macros (use run-macro), list/find jobdefs
 
 PARAMETERS

package/skills/mcp-tool-description-optimizer/SKILL.md

@@ -1,129 +0,0 @@
----
-name: mcp-tool-description-optimizer
-description: >
-  Optimize MCP (Model Context Protocol) tool descriptions for token efficiency and LLM routing accuracy.
-  Use this skill whenever a user shares a raw, verbose, or poorly structured MCP tool description and wants
-  it improved, rewritten, or reviewed. Trigger on phrases like: "optimize this tool description",
-  "rewrite my MCP tool description", "make this tool description more efficient", "clean up my tool spec",
-  "improve how Claude picks my tool", or when a user pastes a JavaScript/TypeScript tool description string
-  and asks for help with it. Also trigger when the user mentions token efficiency, tool routing,
-  or LLM disambiguation in the context of MCP servers.
----
-
-# MCP Tool Description Optimizer
-
-Rewrites verbose or poorly structured MCP tool descriptions into compact, signal-rich versions that
-improve LLM tool selection accuracy while reducing token usage.
-
-## Why this matters
-
-Claude and other LLMs select MCP tools based entirely on the `description` field. Descriptions that are
-too long, redundant, or badly structured waste context tokens and reduce routing precision.
-A well-optimized description:
-- States what the tool does and when to use it upfront
-- Eliminates redundancy (same info repeated across sections)
-- Uses a compact, scannable format (labeled blocks, not nested markdown)
-- Includes clear negative examples to prevent mis-routing
-- Keeps parameters terse — name, type, default, one-line purpose
-
----
-
-## Optimization Process
-
-### Step 1 — Analyze the input description
-
-Before rewriting, identify these problems in the original:
-
-| Problem | Example |
-|---|---|
-| **Redundancy** | Trigger phrases listed in 3+ places |
-| **Filler sections** | "Rationale", "Behavior Summary", "Response Contract" with no routing signal |
-| **Orphaned syntax** | Arrows (`→`) or bullets with no target |
-| **Overlong examples** | Long prose examples when one-liners suffice |
-| **Heavy markdown** | `##` headers for every minor point |
-| **Duplicated parameter docs** | Same param described in both a table and prose |
-
-Call out 2–4 of the most impactful issues before writing the new version.
-
-### Step 2 — Rewrite using the standard template
-
-Use this exact block structure for the output. Omit blocks that don't apply.
-
-```
-<tool-name> — <one-line purpose>.
-
-USE when: <comma-separated user intents or trigger phrases>
-DO NOT USE for: <comma-separated anti-patterns with → redirect where applicable>
-
-PARAMETERS
-- <name>: <type> (default: <val>) — <one-line purpose>
-...
-
-ROUTING RULES
-- "<trigger phrase>" → { param: value }
-- "<trigger phrase>" → { param: value }
-- <ambiguous case> → <ask for clarification | default behavior>
-
-EXAMPLES
-- "<user utterance>" → { param: value, ... }
-- "<user utterance>" → { param: value, ... }
-
-NEGATIVE EXAMPLES (do not route here)
-- "<user utterance>" → <correct tool>
-
-PAGINATION (include only if tool is paginated)
-If returned count === limit → hint: next start = start + limit.
-If start > 1 and result empty → note paging may exceed available items.
-
-ERRORS
-<One or two lines: return structure, hallucination policy>
-```
-
-### Step 3 — Apply these rules consistently
-
-**USE/DO NOT USE block**
-- Write as comma-separated inline list, not a bullet list
-- DO NOT USE entries should name the redirect tool in parentheses where known
-
-**ROUTING RULES block**
-- One rule per line; quote the trigger phrase; use `→ { }` for param mapping
-- Consolidate synonyms on one line: `"cas libs / cas libraries / in cas" → { server: 'cas' }`
-- List the default/fallback rule last
-
-**PARAMETERS block**
-- One line per param: `- name: type (default: val) — purpose`
-- Skip obvious params (e.g. don't explain what `limit` means if it's standard pagination)
-
-**EXAMPLES block**
-- Each example fits on one line
-- For "next page" examples, include the prior call's state inline: `"next" (prev: start:1, limit:10) → { start: 11, limit: 10 }`
-
-**NEGATIVE EXAMPLES block**
-- Only include when mis-routing is a real risk
-- Format: `"<utterance>" → <correct-tool-name>`
-
-**Tone**
-- Imperative, terse. No filler words ("Please note that...", "It is important to...")
-- Never include a "Rationale" or "Behavior Summary" section — if behavior matters, encode it as a rule
-
-### Step 4 — Validate before returning
-
-Check the rewritten description against this list:
-
-- [ ] No trigger phrase appears in more than one block
-- [ ] No orphaned `→` arrows or dangling bullets
-- [ ] Parameter defaults are stated explicitly
-- [ ] Negative examples cover the tool's most common mis-routing risks
-- [ ] Total length is ≤ 50% of the original (target: 30–40% reduction)
-
----
-
-## Output format
-
-Always return:
-
-1. **Analysis** — 2–4 bullet points naming the key issues found in the original
-2. **Rewritten description** — inside a JavaScript code block (matching the user's original code style)
-3. **Change summary** — a short table or bullet list of what changed and why
-
-See `references/examples.md` for before/after examples of real tool descriptions.

package/skills/mcp-tool-description-optimizer/references/examples.md

@@ -1,123 +0,0 @@
-# Before / After Examples
-
-## Example 1 — list-libraries (SAS Viya MCP)
-
-### BEFORE (~620 tokens)
-
-```
-## list-libraries — enumerate CAS or SAS libraries
-
-LLM Invocation Guidance (critical)
-Use THIS tool when the user asks for: "list libs", "list libraries", "show cas libs", "show sas libs",
-"what libraries are available", "list caslib(s)", "enumerate libraries", "libraries in cas", "libraries in sas".
-DO NOT use this tool when the user asks for: tables inside a specific library (choose listTables),
-columns/metadata of a table, job/program execution, models, or scoring.
-
-Trigger Phrase → Parameter Mapping
-- "cas libs" / "in cas" / "cas libraries" → { server: 'cas' }
-- "sas libs" / "in sas" / "base sas libraries" → { server: 'sas' }
-- "all libs" / "all libs" -> {server: 'all'}
-→ { server: 'all' }
-- "next" (after prior call) → { start: previous.start + previous.limit }
-- "first 20 cas libs" → { server: 'cas', limit: 20 }
-- If server unspecified: default to all.
-
-Parameters
-- server (cas|sas|all, default 'all')
-- limit (integer > 0, default 10)
-- start (1-based offset, default 1)
-- where (optional filter expression, default '')
-
-Response Contract
-Return JSON-like structure from helper; consumers may extract an array of library objects/names.
-If number of returned items === limit supply a pagination hint: start = start + limit.
-
-Behavior Summary
-- Pure listing; no side effects.
-- If ambiguous short request like "list" or "libs" and no prior context: assume { server: 'cas' }.
-- If user explicitly asks for ALL (e.g. "all cas libs") and count likely large, honor limit=50 unless
-  user supplies a value; include note about paging.
-
-Disambiguation Rules
-- If user mentions a singular library name plus desire for tables ("list tables in SASHELP") choose
-  listTables (not this tool).
-- If user mixes "tables" and "libraries" ask for clarification unless clearly about libraries.
-
-Examples
-- "list libraries" → { server: 'all', start:1, limit:10 }
-- "list libs" → { server: 'all', start:1, limit:10 }
-- "list sas libs" → { server: 'sas' }
-- "list cas libraries" → { server: 'cas' }
-- "show me 25 cas libraries" → { server:'cas', limit:25 }
-- "next" (after prior call {start:1,limit:10}) → { start:11, limit:10 }
-- "filter cas libs" (no criterion) → ask: "Provide a filter or continue without one?"
-
-Negative Examples (do not route here)
-- "list tables in public" (route to list-tables)
-- "list models, list tables, list jobs, list jobdef and similar request"
-- "describe library" (likely list-tables or table-info depending on follow-up)
-- "run program to make a lib" (run-sas-program tool)
-
-Error Handling
-- On backend error: return structured error with message field; do not hallucinate libraries.
-- Empty result set → return empty list plus (if start>1) a hint that paging may have exceeded available items.
-
-Rationale
-Concise, signal-rich description increases probability this spec is selected for generic library
-enumeration intents.
-```
-
-### AFTER (~210 tokens)
-
-```
-list-libraries — enumerate CAS or SAS libraries.
-
-USE when: list/show/enumerate libraries, caslibs, sas libs, available libraries
-DO NOT USE for: listing tables in a library (→ list-tables), column/table metadata, job execution, models, scoring
-
-PARAMETERS
-- server: 'cas' | 'sas' | 'all' (default: 'all')
-- limit: integer > 0 (default: 10)
-- start: 1-based offset (default: 1)
-- where: optional filter expression (default: '')
-
-ROUTING RULES
-- "cas libs / cas libraries / in cas"          → { server: 'cas' }
-- "sas libs / sas libraries / in sas"          → { server: 'sas' }
-- "all libs / all libraries"                   → { server: 'all' }
-- "all cas libs" with no limit given           → { server: 'cas', limit: 50 } + paging note
-- "next" after prior call (start:S, limit:L)   → { start: S + L, limit: L }
-- "filter cas libs" with no filter given       → ask: "What filter expression should I apply?"
-- server unspecified / ambiguous "list"/"libs" → { server: 'cas' }
-
-EXAMPLES
-- "list libraries"                → { server: 'all', start: 1, limit: 10 }
-- "list cas libraries"            → { server: 'cas', start: 1, limit: 10 }
-- "show me 25 sas libs"           → { server: 'sas', limit: 25, start: 1 }
-- "next" (prev: start:1,limit:10) → { server: <same>, start: 11, limit: 10 }
-
-NEGATIVE EXAMPLES (do not route here)
-- "list tables in SASHELP"        → list-tables
-- "list models / jobs / jobdefs"  → respective tools
-- "run a program to create a lib" → run-sas-program
-
-PAGINATION
-If returned count === limit → hint: next start = start + limit.
-If start > 1 and result empty → note paging may exceed available items.
-
-ERRORS
-Return structured error with message field. Never hallucinate library names.
-```
-
-**Token reduction: ~66%**
-
----
-
-## Key patterns illustrated
-
-- Trigger phrases consolidated from 3 blocks → 1 ROUTING RULES block
-- "Rationale", "Behavior Summary", "Response Contract" sections eliminated
-- Orphaned `→ { server: 'all' }` arrow removed
-- Parameter defaults made explicit inline
-- Examples trimmed to one line each
-- Negative examples now name the redirect tool explicitly