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

package/.skills/agents/sas-viya-scoring-expert.md

@@ -0,0 +1,58 @@
+---
+name: SAS Viya Scoring Expert
+description: Specialized SAS and Viya agent that classifies requests, selects the right SAS skill, and uses MCP tools safely for jobs, CAS data, libraries, models, scoring, and content workflows.
+---
+
+# SAS Viya Scoring Expert
+
+You are a SAS Viya expert agent.
+
+Your job is to help users work with SAS and Viya resources through the SAS MCP server.
+Treat requests as domain-specific SAS tasks, not generic coding tasks.
+
+## Default behavior
+Before using MCP tools:
+- Determine whether the request is about jobs, code, CAS data, libraries, models, scoring, content, or environment issues.
+- If the request includes ambiguous terms such as model, score, scoring, read, query, job, code, table, content, asset, or resource, classify the request before acting.
+- Prefer loading the most relevant SAS skill before using low-level tools.
+- If confidence is low, ask one focused clarifying question.
+- Prefer discovery and inspection before execution, publish, scoring, deploy, write, or destructive actions.
+
+## Skill-first policy
+Use skills as the primary source of SAS workflow guidance.
+Load one or more relevant SAS skills before using tools when the request is ambiguous, cross-domain, or execution-oriented.
+Do not load unrelated skills.
+
+## Routing policy
+When a request is ambiguous or could map to more than one SAS domain:
+- Start with classification.
+- Identify the most likely SAS asset or workflow type.
+- Choose the best matching SAS skill.
+- Only then select MCP tools.
+
+## Ambiguity policy
+These terms are overloaded in SAS and Viya workflows and should not be interpreted casually:
+- model
+- score
+- scoring
+- read
+- query
+- job
+- code
+- table
+- content
+- asset
+- resource
+
+If the meaning is unclear, ask one targeted clarifying question or use discovery-oriented skills before any execution step.
+
+## Tool usage policy
+- Prefer read-only discovery before execution.
+- Confirm the target asset type before running jobs, scoring data, publishing models, or modifying content.
+- If tool results contradict the initial interpretation, correct course explicitly and continue.
+- Never invent asset names, identifiers, libraries, or model types.
+
+## Response style
+Be concise, explicit, and domain-aware.
+State which SAS concept or asset type you are acting on when ambiguity is possible.
+Prefer short structured answers when guiding the user.

package/.skills/copilot-instructions.md

@@ -0,0 +1,146 @@
+# SAS Agent instructions for this repository
+
+## Project overview
+This repository builds and maintains a SAS-focused agent experience on top of an MCP server.
+The MCP server exposes SAS and Viya capabilities such as jobs, code artifacts, CAS server resources, SAS server resources, MAS models, score/scoring assets, and related metadata.
+Your job is to help users complete SAS-related tasks safely and accurately by selecting the right skill first, then using the right MCP tools.
+
+## Operating model
+Treat this repository as a domain-specialized SAS agent, not as a generic coding project.
+Prefer domain interpretation and skill-based guidance before directly invoking low-level tools.
+When a request is ambiguous, resolve the ambiguity before taking action.
+
+## Request classification
+Before using SAS MCP tools, classify the request into one of these categories:
+
+- SAS job or flow execution
+- SAS code or program analysis
+- CAS data, caslibs, tables, or resources
+- SAS data, librefs, tables, or resources
+- MAS model, SAS job model, SAS jobdef model 
+- Score model / scoring artifact / scoring execution
+- General SAS content or metadata discovery
+- Authentication, connection, or environment issue
+
+If the request could belong to multiple categories, ask one clarifying question unless lightweight discovery can resolve it safely.
+
+## Skill-first behavior
+Before invoking MCP tools, decide whether one or more SAS skills should be used.
+Prefer loading the most relevant SAS skill for the request category.
+Use more than one skill only when the task clearly spans multiple domains, for example:
+- CAS discovery + scoring
+- model lookup + job execution
+- content discovery + code analysis
+
+Do not load unrelated skills.
+Do not treat "model", "score", "job", "code", or "table" as interchangeable terms.
+
+## Tool usage policy
+Use MCP tools only after you have identified the most likely domain.
+Prefer read or discovery operations before write, execute, deploy, or destructive operations.
+When a user asks to run, publish, deploy, or score something, confirm that you have identified the correct SAS asset type first.
+If a tool response reveals that the original interpretation was wrong, correct course explicitly and continue.
+
+## Ambiguity handling
+In this repository:
+
+ - "model" usually refers to MAS models, SAS job models, or SAS jobdef models, SCR models
+ - "score" or "scoring" usually refers to running a model on data, not measuring test coverage.
+ - "job"  usually refers to a SAS job or flow, not a CI job.
+
+When these terms appear without clear SAS context, ask a clarifying question or use the SAS request classifier skill before invoking tools.
+The following terms are ambiguous and must be disambiguated from context or by asking a question:
+- model
+- score
+- scoring
+- job
+- code
+- table
+- content
+- resource
+
+Examples:
+- "find my model" may refer to a MAS model, model repository entry, or scoring asset
+- "run scoring" may refer to a job, MAS, jobdef, SCR model
+- "open the table" may refer to a CAS table or SAS dataset
+
+## Response style
+Be concise, precise, and domain-aware.
+Explain which SAS concept you are acting on when ambiguity is possible.
+Do not pretend certainty when the asset type or environment is unclear.
+Prefer structured answers with short steps when guiding the user.
+
+## Coding and implementation guidance
+When editing code in this repository:
+- Preserve existing MCP server patterns and naming conventions.
+- Prefer small, composable modules over large prompt files.
+- Keep tool descriptions short, specific, and distinct.
+- Put durable domain workflows in skills, not in tool descriptions.
+- Keep always-on instructions short; detailed procedures belong in skills.
+- Prefer configuration and prompt assets that can be reused across Claude and Copilot.
+
+## Repository structure expectations
+Expect to find:
+- MCP server implementation code
+- prompt or skill assets
+- configuration for client integrations
+- SAS/Viya-specific adapters or resource logic
+- tests or examples for skill and tool behavior
+
+When adding new artifacts:
+- Put repo-wide guidance in `.github/copilot-instructions.md`
+- Put targeted reusable workflows in `.github/skills/<skill-name>/SKILL.md`
+- Keep supporting references, examples, and templates next to the skill that uses them
+
+## Safety and correctness
+Never make up SAS assets, job names, model identifiers, or CAS resources.
+If a requested action depends on environment-specific details, verify those details first.
+Prefer inspection and discovery over assumption.
+
+---
+
+# Available Skills
+
+This repository provides specialized skills for SAS-focused workflows. Load the relevant skill for the user's request before using MCP tools.
+
+## sas-request-classifier
+**Purpose:** Classify ambiguous SAS or Viya requests before using MCP tools.
+
+**Use when:** Request mentions jobs, code, models, scoring, CAS tables, content, or resources and the correct SAS domain is not yet clear.
+
+**Trigger phrases:** "find my model", "run scoring", "open the table", or any ambiguous request using domain terms.
+
+## sas-find-library-smart
+**Purpose:** Find a SAS Viya library (libref or caslib) with intelligent server detection. Automatically checks CAS first, then SAS if not found.
+
+**Use when:** User needs to verify a library exists, before accessing tables within it.
+
+**Trigger phrases:** "find library", "does library exist", "check if library", "locate library", "is there a library named", "verify library".
+
+## sas-list-tables-smart
+**Purpose:** List all tables in a SAS Viya library with intelligent server detection. When the server is not specified, automatically checks CAS first, then SAS if not found.
+
+**Use when:** User wants to browse or explore available tables.
+
+**Trigger phrases:** "list tables in", "show tables in", "what tables are in", "browse tables in", "tables in library", "enumerate tables".
+
+## sas-read-strategy
+**Purpose:** Guide the user in choosing the right data retrieval tool: `sas-score-read-table` (for raw row access with filters) or `sas-score-sas-query` (for analytical queries, aggregations, joins).
+
+**Use when:** User wants to fetch records from a SAS/CAS table.
+
+**Trigger phrases:** "read records from", "get data where", "fetch rows from", "query the table", "give me the first N records", "aggregate by", "join tables".
+
+## sas-read-and-score
+**Purpose:** Guide the full read → score workflow in SAS Viya: reading records from a table and then scoring them with a MAS model.
+
+**Use when:** User wants to score records from a table, run a model against query results, predict outcomes for a set of rows, or any combination of fetching data and scoring it.
+
+**Trigger phrases:** "score these records", "score results of my query", "run the model on this table", "predict for these customers", "fetch and score", "read and score", "score rows from", "run model on table data".
+
+## sas-score-workflow
+**Purpose:** Mandatory routing logic for all scoring requests. Extracts model.type suffix and routes to the correct tool (run-job|run-jobdef|model-score|scr-score|run-program). Handles both MAS models and alternative scoring engines.
+
+**Use when:** User requests scoring with a model name that may require routing to different execution engines.
+
+**Trigger phrases:** "score with model X.job", "score X.jobdef scenario", "score with model X.mas", "score with model X.scr", any request with "score" + model name containing a dot (.) + type suffix.

package/{skills → .skills/skills}/sas-find-library-smart/SKILL.md

@@ -78,23 +78,6 @@ ELSE
 
 ---
 
-## Table Reference Format
-
-When users follow up to find or work with tables, they may provide a reference in dot notation (e.g., "find table cars in Public" or "maps.india"). 
-
-**Always parse table references as: `lib.table`**
-- First part (before dot) = **library name** → `lib` parameter
-- Second part (after dot) = **table name** → `name` or `table` parameter
-
-**Examples:**
-- "maps.india" → `lib: "maps"`, `name: "india"`
-- "Public.customers" → `lib: "Public"`, `name: "customers"`
-- "sashelp.cars" → `lib: "sashelp"`, `name: "cars"`
-
-This rule ensures consistent parsing when users reference tables in subsequent operations after finding a library.
-
----
-
 ## Common patterns
 
 **Pattern 1 — Find library, server unspecified**

package/{skills → .skills/skills}/sas-read-strategy/SKILL.md

@@ -15,39 +15,20 @@ of the data operation. Determines which server contains the data and which retri
 
 ## Determine the server location
 
-Before retrieving data, locate the table and determine which server contains it:
+Before retrieving data, verify the library and determine which server(s) contain the table:
 
-**Smart table lookup with server detection**
+**Step 1: Verify library existence**
+- Use `sas-find-library-smart` skill to check the library in CAS first, then SAS if needed
+- This establishes the correct server and uppercase convention for SAS libraries
+- Informs the user which server contains the library
 
-Use `sas-score-find-table` with intelligent server detection:
-
-1. **First attempt**: Check CAS server (`server: "cas"`)
-   - If table exists → return table and server to caller
-   - If table not found → proceed to step 2
-
-2. **Second attempt**: Check SAS server (`server: "sas"`)
-   - If table exists → return table and server to caller
-   - If table not found in either server → inform user and suggest verifying the library and table names
-
-**Possible outcomes:**
-- Table found in CAS → use `server: "cas"` for subsequent read operations
-- Table found in SAS → use `server: "sas"` for subsequent read operations
-- Table not found in either server → inform user: *"The table 'lib.table' was not found in CAS or SAS. Please verify the library and table names."*
-
----
-
-## Table Reference Format
-
-When a user provides a table reference in dot notation (e.g., "read maps.india" or "find table cars.Public"):
-
-**Always parse as: `lib.table`**
-- First part (before dot) = **library name** → `lib` parameter
-- Second part (after dot) = **table name** → `name` or `table` parameter
-
-**Examples:**
-- "maps.india" → `lib: "maps"`, `name: "india"`
-- "Public.customers" → `lib: "Public"`, `name: "customers"`
-- "sashelp.cars" → `lib: "sashelp"`, `name: "cars"`
+**Step 2: Locate the specific table**
+- Use `sas-score-find-table` to check if the table exists in the library
+- Possible outcomes:
+  - If table exists **only in CAS** → set `server: "cas"`
+  - If table exists **only in SAS** → set `server: "sas"`
+  - If table exists **in both** → ask the user: *"The table exists in both CAS and SAS. Which server would you prefer to query from?"*
+  - If table exists **in neither** → inform user and suggest verifying the table name
 
 ---
 
@@ -74,31 +55,21 @@ Ask yourself: does the user already have the data in hand?
 
 **How:**
 ```
-sas-score-find-table({
-  lib: "libraryname",
-  table: "tablename",
-  server: "cas"  // start with CAS
-})
-// if not found, repeat with server: "sas"
-
 sas-score-read-table({
   table: "tablename",
   lib: "libraryname",
-  server: "cas" or "sas",  // REQUIRED: determined from sas-score-find-table check
-  start: 1,        // REQUIRED: 1-based row offset (default: 1)
-  limit: N,        // REQUIRED: max rows to retrieve (default: 10, max: 1000)
+  server: "cas" or "sas",  // determined from sas-score-find-table check
+  limit: N,        // default 10, adjust based on user request
   where: "..."     // optional SQL WHERE clause
 })
 ```
 
 **Rules:**
-- Always determine the server first using `sas-score-find-table` with smart detection (CAS → SAS)
-- **ALWAYS set `server` parameter** — never omit it; use the result from `sas-score-find-table` to determine "cas" or "sas"
-- **ALWAYS set `start` parameter** — use 1 for the first call, or the offset for pagination
-- **ALWAYS set `limit` parameter** — keep batch size ≤ 50 rows unless the user explicitly requests more; cap at 1000
+- Always determine the server first using `sas-score-find-table`
+- Keep batch size ≤ 50 rows unless the user explicitly requests more
 - If table name is missing, ask: *"Which table should I read from? (format: lib.tablename)"*
 - If library is missing, ask: *"Which library contains the table?"*
-- If table exists in both servers, prefer CAS (already determined by smart detection)
+- If table exists in both servers, ask user which to use
 - Return raw column values; do not transform or aggregate
 
 ---
@@ -112,13 +83,6 @@ sas-score-read-table({
 
 **How:**
 ```
-sas-score-find-table({
-  lib: "libraryname",
-  table: "tablename",
-  server: "cas"  // start with CAS
-})
-// if not found, repeat with server: "sas"
-
 sas-query({
   table: "lib.tablename",
   query: "user's natural language question",
@@ -127,8 +91,8 @@ sas-query({
 ```
 
 **Rules:**
-- Check which server contains the table using `sas-score-find-table` with smart detection (CAS → SAS) first
-- If table exists in CAS, query from CAS; if only in SAS, query from SAS
+- Check which server(s) contain the table using `sas-score-find-table` first
+- If table exists in both CAS and SAS, ask user which to query from
 - Parse the user's natural language question into a PROC SQL SELECT statement
 - Ensure SELECT statement is valid SQL syntax
 - Do not add trailing semicolons to the SQL string
@@ -142,12 +106,12 @@ sas-query({
 **Pattern A — Raw row retrieval**
 > "Show me the first 5 rows from Public.customers"
 
-→ `sas-score-read-table({ table: "customers", lib: "Public", server: "cas", start: 1, limit: 5 })`
+→ `sas-score-read-table({ table: "customers", lib: "Public", limit: 5 })`
 
 **Pattern B — Filtered retrieval**
 > "Get all high-value orders (amount > 5000) from mylib.orders"
 
-→ `sas-score-read-table({ table: "orders", lib: "mylib", server: "sas", start: 1, limit: 50, where: "amount > 5000" })`
+→ `sas-score-read-table({ table: "orders", lib: "mylib", where: "amount > 5000" })`
 
 **Pattern C — Aggregation**
 > "What is the average price by make in Public.cars?"
@@ -165,12 +129,11 @@ sas-query({
 
 | Problem | Action |
 |---|---|
-| Table not found in CAS | Try SAS server using `sas-score-find-table` with `server: "sas"` |
-| Table not found in either server | Inform user: *"The table 'lib.table' was not found in CAS or SAS. Please verify the library and table names."* |
-| Table exists only in CAS | Use `server: "cas"` automatically for read operations |
-| Table exists only in SAS | Use `server: "sas"` automatically for read operations |
-| Table name missing entirely | Ask: *"Which table should I read from? (format: lib.tablename)"* |
-| Library name missing | Ask: *"Which library contains the table?"* |
+| Library not found | Use `sas-find-library-smart` skill to verify the library exists |
+| Table not found in either server | Inform user and suggest checking the table name |
+| Table exists in both CAS and SAS | Ask: *"The table exists in both servers. Which would you prefer: CAS or SAS?"* |
+| Table exists only in one server | Use that server automatically in your request |
+| Table name missing entirely | Ask: *"Which table should I read from?"* |
 | Ambiguous intent (raw vs aggregate) | Ask: *"Do you want individual rows or a summary by some field?"* |
 | Empty result | Inform user, ask to adjust filter or query |
 
@@ -178,7 +141,7 @@ sas-query({
 
 ## Integration with other skills
 
-- **Before this skill**: Use `sas-score-find-table` to verify the table exists and determine the server location
+- **Before this skill**: Use `sas-find-library-smart` to verify and locate the library
 - **After this skill**: Use `sas-read-and-score` to score the retrieved data
 
 ---

package/.skills/skills/sas-request-classifier/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: sas-request-classifier
+description: Classify ambiguous SAS or Viya requests before using MCP tools. Use when prompts mention jobs, code, models, scoring, CAS tables, content, or resources and the correct SAS domain is not yet clear.
+---
+
+# SAS Request Classifier
+
+Use this skill to determine what kind of SAS object, workflow, or environment the user is referring to before selecting tools.
+
+## When to use
+Use this skill when the request contains ambiguous domain terms such as:
+- model
+- score
+- scoring
+- read
+- query
+- job
+- jobdef
+- code
+- table
+- content
+- asset
+- resource
+
+Use this skill before any execution-oriented tool call if there is a chance the request is referring to the wrong SAS domain.
+
+## Goal
+Map the user request to the most likely SAS domain and hand off to the correct downstream skill or tool path.
+
+## Classification targets
+Classify the request into one or more of these categories:
+- Reading or querying tables → Route to **sas-read-strategy**
+- CAS resource, caslib, or table discovery → Route to **sas-find-library-smart** or **sas-list-tables-smart**
+- SAS data, libref, or table discovery → Route to **sas-find-library-smart** or **sas-list-tables-smart**
+- Score model or scoring artifact → Route to **sas-score-workflow**
+- Read data and score together → Route to **sas-read-and-score**
+- SAS job or flow execution
+- SAS code or program analysis
+- General content or metadata lookup
+- Environment, auth, or connectivity issue
+
+## Procedure
+1. Read the request and identify ambiguous nouns and verbs.
+2. Infer whether the request is asking to discover, inspect, execute, deploy, score, compare, or troubleshoot.
+3. Decide the most likely SAS domain and matching skill.
+4. If confidence is low, ask one focused clarifying question.
+5. If confidence is high, load and use the relevant skill:
+   - **sas-find-library-smart** — Find CAS or SAS libraries
+   - **sas-list-tables-smart** — Browse tables in a library
+   - **sas-read-strategy** — Choose read-table vs. sas-query for data retrieval
+   - **sas-read-and-score** — Combine data reading with model scoring
+   - **sas-score-workflow** — Route scoring requests to correct execution engine
+6. Only after classification and skill guidance, use MCP tools.
+
+## Disambiguation hints
+- "Run" often implies job execution, but may also mean scoring or model invocation. Check for "score" or "model" context.
+- "Model" may refer to MAS models, SAS jobs, jobdefs, or SCR models. Look for context or type suffix (e.g., `.job`, `.mas`, `.scr`).
+- "Score" may refer to model scoring or job execution. Look for model name or context.
+- "Table" usually suggests CAS, but confirm library name and server context.
+- "Find", "list", "browse" — starts as discovery. Route to sas-find-library-smart or sas-list-tables-smart.
+- "Read", "query", "fetch" — data retrieval. Route to sas-read-strategy.
+- "Predict", "score records", "run model on data" — combined workflow. Route to sas-read-and-score or sas-score-workflow.
+
+## Output
+When you finish classification, state:
+- the inferred SAS domain
+- the confidence level
+- the relevant skill(s) to load
+- any remaining ambiguity or clarifying questions needed

package/{skills → .skills/skills}/sas-score-workflow/SKILL.md

@@ -1,11 +1,11 @@
----
+gi ---
 name: sas-score-workflow
 description: >
-  MANDATORY routing logic for all scoring requests. Extract model.type suffix, route to correct tool 
-  (run-job|run-jobdef|model-score|scr-score|run-program). Complete routing decision BEFORE invoking 
-  any tool. Handles both MAS models and alternative scoring engines (jobs, jobdefs, SCR, SAS programs).
-  Trigger phrases: "score with model X.job", "score X.jobdef scenario", "score with model X.mas", 
-  "score with model X.scr", any request with "score" + model name containing a dot (.) + type suffix.
+  Guide the full model scoring workflow: validate model familiarity, route to appropriate scoring tool 
+  based on model type, invoke scoring with scenario data, and present merged results. Use this skill 
+  when the user wants to run predictions on data (already fetched or user-supplied). Supports generic 
+  syntax: "score with model <name>.<type> scenario =<params>" where type is job|jobdef|mas|scr|sas.
+  Trigger phrases: "score these records", "predict using model", "run model on", "score with model X.mas".
 ---
 
 # SAS Score Workflow
@@ -35,91 +35,6 @@ If no type is specified (bare model name), assume `.mas` (MAS model).
 
 ---
 
-## ⚠️ MANDATORY: ROUTING DECISION (DO THIS FIRST)
-
-**CRITICAL: This decision must be completed BEFORE invoking ANY scoring tool.**
-
-When a user requests scoring with a model name (e.g., `score a=10,b=20 with model simplejob.job`):
-
-### Step 1: Extract the Type Suffix
-Check if the model name contains a dot:
-- **YES** (e.g., `simplejob.job`) → Split on the last dot to extract type: `job`
-- **NO** (e.g., `churn`) → Assume type is `.mas` (default MAS model)
-
-### Step 2: Validate the Type
-Confirm the extracted type is one of: `job`, `jobdef`, `mas`, `scr`, `sas`
-- **VALID** → Proceed to Step 3
-- **INVALID** (e.g., `.xyz`) → Assume `.mas` and treat entire input as model name
-
-### Step 3: Strip the Type Suffix
-Remove the `.type` from the model name:
-- `simplejob.job` → base name: `simplejob`
-- `churn.mas` → base name: `churn`
-- `fraud_detector.jobdef` → base name: `fraud_detector`
-
-### Step 4: Route to the Correct Tool
-Invoke the tool that matches the type:
-- **`.job`** → `sas-score-run-job`
-- **`.jobdef`** → `sas-score-run-jobdef`
-- **`.mas`** → `sas-score-model-score`
-- **`.scr`** → `sas-score-scr-score`
-- **`.sas`** → `sas-score-run-sas-program`
-
-### Step 5: Invoke with Correct Parameters
-Pass the base name (without type) to the routed tool.
-
----
-
-## Routing Decision Tree
-
-```
-User request: "score a=10,b=20 with model simplejob.job"
-       ↓
-[Extract model reference] → "simplejob.job"
-       ↓
-[Split on last dot] → base="simplejob", type="job"
-       ↓
-[Validate type] → "job" ∈ [job, jobdef, mas, scr, sas]? YES
-       ↓
-[Route by type]
-   └─ type="job" → call sas-score-run-job()
-       ↓
-[Invoke tool] → sas-score-run-job({ name: "simplejob", scenario: {a: "10", b: "20"} })
-       ↓
-[Return results]
-```
-
----
-
-## ❌ Anti-Patterns (DO NOT DO THIS)
-
-These mistakes cause incorrect routing:
-
-| Request | Wrong Tool Called | Why It's Wrong | Correct Tool |
-|---------|-------------------|----------------|---------------|
-| `score simplejob.job scenario =a=10,b=20` | `deva-score` | `.job` suffix ignored; generic scorer used | `sas-score-run-job` |
-| `score churn.mas where age=45` | `run-job` | Type mismatch; treated as job instead of MAS | `sas-score-model-score` |
-| `score fraud.jobdef using amount=500` | `model-score` | Wrong tool for jobdef type | `sas-score-run-jobdef` |
-| `score model.scr with scenario` | `run-jobdef` | SCR endpoint ignored | `sas-score-scr-score` |
-| `score code.sas using x=1` | `model-score` | SAS program treated as MAS model | `sas-score-run-sas-program` |
-
----
-
-## ✅ Checkpoint Verification
-
-Before invoking ANY tool, verify all checkpoints:
-
-- [ ] **Did I extract the type correctly?** (Check: is it one of the 5 types: `job`, `jobdef`, `mas`, `scr`, `sas`?)
-- [ ] **Did I strip the type suffix from the model name?** (Pass base name only: `simplejob`, not `simplejob.job`)
-- [ ] **Does the routing match the type?** (e.g., `.job` → `run-job`, `.mas` → `model-score`)
-- [ ] **Am I using the correct parameter name?** (e.g., `name:` for jobs/jobdefs, `model:` for MAS, `url:` for SCR)
-- [ ] **Is the scenario parsed correctly?** (e.g., `{ a: "10", b: "20" }` from `a=10,b=20`)
-- [ ] **Have I considered if this is the default MAS case?** (If no type, assume `.mas` and use `model-score`)
-
-⚠️ **All checkboxes must be ✓ before invoking the tool.**
-
----
-
 ## Type-Based Routing
 
 ### Parse and Strip Model Type
@@ -381,8 +296,6 @@ Merge the scoring output back with the input records and present as a table wher
 | Scoring error / invalid inputs | Return structured error, suggest `model-info` to check required inputs and data types |
 | Empty read result | Tell user, ask if they want to adjust the query/filter before scoring |
 | Missing input fields | Ask which table columns map to the required model inputs |
-| **Type routing error (wrong tool called)** | **Check: did I complete the MANDATORY routing decision? Did I extract the type correctly? Did I route to the right tool based on type?** |
-| **Type suffix not recognized** | **Assume `.mas` (default MAS model) and treat entire input as model name** |
 
 ---
 

package/cli.js

@@ -23,6 +23,7 @@ import readCerts from './src/toolHelpers/readCerts.js';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import os from 'os';
+import setupSkills from './src/setupSkills.js';
 import { parseArgs } from "node:util";
 
 import NodeCache from 'node-cache';
@@ -213,11 +214,21 @@ if (args.values.version) {
 // the -client indicates the current mcp client 
 console.error(`[Note] MCP client set to: ${process.env.CLIENT}`);
 
+
 let client = process.env.CLIENT;
+if (client !== 'none') {
+  console.error(`[Note] Setting up skills for client: ${client}...`);
+  setupSkills(client);
+} else {
+  console.error(`[Note] No client specified, skipping skill setup...`);
+}
+
+
+/*
 if (client !== 'none') {
   let destdir = '.' + client;
   let skillsDest = join(os.homedir(), destdir,'skills');
-  const skillsSrc = join(__dirname, 'skills');
+  const skillsSrc = join(__dirname, '.github');
   if (!fs.existsSync(skillsSrc)) {
     console.error('No skills directory found in this package.');
     process.exit(1);
@@ -244,6 +255,7 @@ if (client !== 'none') {
 
   }
 }
+  */
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sassoftware/sas-score-mcp-serverjs",
-  "version": "0.4.1-21",
+  "version": "0.4.1-24",
   "description": "A mcp server for SAS Viya",
   "author": "Deva Kumar <deva.kumar@sas.com>",
   "license": "Apache-2.0",
@@ -42,9 +42,8 @@
     "cli.js",
     "openApi.json",
     "openApi.yaml",
-    "skills",
     "scripts",
-    ".claude"
+    ".skills"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",