@sassoftware/sas-score-mcp-serverjs 1.0.1-9 → 1.1.1

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

@@ -1,74 +0,0 @@
----
-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:
-- Resource existence lookup (library/table/model/job/jobdef) -> Route to **sas-find-resource-strategy**
-- Resource listing (library/table/model/job/jobdef) -> Route to **sas-list-resource-strategy**
-- Reading or querying tables → Route to **sas-read-strategy**
-- CAS resource, SAS resource, caslib, or table discovery → Route to **sas-find-library-smart** 
-- SAS data, libref, or table discovery → Route to **sas-find-library-smart** 
-- Score model or scoring artifact → Route to **sas-score-workflow-strategy**
-- Read data and score together → Route to **sas-read-and-score-strategy**
-- 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-resource-strategy** — Unified find-only strategy for library/table/model/job/jobdef
-   - **sas-list-resource-strategy** — Unified list strategy for library/table/model/job/jobdef with non-null pagination defaults
-   - **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-strategy** — Combine data reading with model scoring
-   - **sas-score-workflow-strategy** — 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 or SAS but confirm library name and server context.
-- "Find" — resource lookup. Route to sas-find-resource-strategy.
-- "List" or "browse" — resource exploration. Route to sas-list-resource-strategy.
-- "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-strategy  or sas-score-workflow-strategy.
-
-## 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/sas-score-workflow-strategy/SKILL.md

@@ -1,314 +0,0 @@
----
-name: sas-score-workflow-strategy
-description: >
-  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
-
-Orchestrates model validation, type-based routing, scoring invocation, and result presentation. 
-Handles both MAS models and alternative scoring engines (jobs, jobdefs, SCR, SAS programs).
-
----
-
-## Generic Scoring Syntax
-
-Users can invoke scoring with a unified syntax that automatically routes to the correct tool:
-
-```
-score with model <name>.<type> [scenario =<key=value pairs>]
-score <name>.<type> [scenario =<key=value pairs>]
-```
-
-**Type determines the routing:**
-- `.job` → route to `sas-score-run-job` with scoring parameters
-- `.jobdef` → route to `sas-score-run-jobdef` with scoring parameters
-- `.mas` → route to `sas-score-model-score` (Model Analytical Service — default)
-- `.scr` → route to `sas-score-scr-score` (SAS Container Runtime)
-- `.sas` → route to `sas-score-run-sas-program` to run sas program in folder
-
-If no type is specified (bare model name), assume `.mas` (MAS model).
-
----
-
-## Type-Based Routing
-
-### Parse and Strip Model Type
-
-When a user provides a model name with a type suffix (e.g., `simplejon.job`, `churn.mas`):
-
-1. **Extract the type:** Split on the last dot to identify the type suffix
-   - `simplejon.job` → type = `job`, base name = `simplejon`
-   - `churn.mas` → type = `mas`, base name = `churn`
-   - `fraud_detector.jobdef` → type = `jobdef`, base name = `fraud_detector`
-
-2. **Validate the type:** Confirm it matches one of the supported types: `job`, `jobdef`, `mas`, `scr`, `sas`
-   - If type is unrecognized, assume `.mas` (default MAS model) and treat the entire input as the model name
-
-3. **Strip the type suffix:** Remove the `.type` from the model name before passing to the routing tool
-   - **Critical:** Always pass the base name (without the dot and type) to the invoked tool
-   - `simplejon.job` → pass `simplejon` to `sas-score-run-job`
-   - `churn.mas` → pass `churn` to `sas-score-model-score`
-   - `fraud_detector.jobdef` → pass `fraud_detector` to `sas-score-run-jobdef`
-
-### Type: `.mas` (Model Aggregation Service)
-- **Tool**: `sas-score-model-score`
-- **Use for**: Standard MAS-deployed predictive models
-- **Example**: `score with model churn.mas scenario =age=45,income=60000`
-- **Invocation**: `sas-score-model-score({ model: "churn", scenario: {...} })`
-
-### Type: `.job` (SAS Viya Job)
-- **Tool**: `sas-score-run-job`
-- **Use for**: Pre-built scoring jobs with parameters
-- **Example**: `score with model monthly_scorer.job scenario =month=10,year=2025`
-- **Invocation**: `sas-score-run-job({ name: "monthly_scorer", scenario: {...} })`
-
-### Type: `.jobdef` (SAS Viya Job Definition)
-- **Tool**: `sas-score-run-jobdef`
-- **Use for**: Job definitions that perform scoring logic
-- **Example**: `score with model fraud_detector.jobdef using amount=500,merchant=online`
-- **Invocation**: `sas-score-run-jobdef({ name: "fraud_detector", scenario: {...} })`
-
-### Type: `.scr` (Score Code Runtime)
-- **Tool**: `sas-score-scr-score`
-- **Use for**: Models deployed in SCR containers (REST endpoints)
-- **Example**: `score https://scr-host/models/loan.scr using age=45,credit=700`
-- **Invocation**: `sas-score-scr-score({ url: "https://scr-host/models/loan", scenario: {...} })`
-
-### Type: `.sas` (SAS Program / SQL)
-- **Tool**: `sas-score-run-sas-program`
-- **Use for**: Custom SAS or SQL scoring code
-- **Example**: `score my_scoring_code.sas using x=1,y=2`
-- **Invocation**: `sas-score-run-sas-program({ folder: "my_scoring_code", scenario: {...} })`
-
-
-
----
-
-## Scenario Parsing
-
-The scenario parameter (comma-separated key=value pairs) is parsed into an object:
-
-```
-scenario =age=45,income=60000,region=South
-  ↓ parsed as:
-{ age: "45", income: "60000", region: "South" }
-```
-
-Accepted formats:
-- **String**: `age=45,income=60000`
-- **Object**: `{ age: 45, income: 60000 }`
-- **Array** (batch): `[ {age:45, income:60000}, {age:50, income:75000} ]`
-
----
-
-## Integration with other skills
-
-- **Before scoring table data**: Use `sas-find-resource-strategy` to verify library/table/model resources, then `sas-read-strategy` to fetch records
-- **For read + score workflows**: Use `sas-read-and-score-strategy` for the complete end-to-end pattern
-
----
-
-## Step 1 — Check model familiarity before scoring
-
-Score immediately if:
-- The user names a specific model they've used before in this session, OR
-- The model name matches a previously confirmed model in the conversation
-
-Pause and suggest investigation if:
-- The model name is new, vague, or misspelled-looking (e.g. "the churn one", "that cancer model")
-- The user seems unsure of the required input variable names
-
-**Suggested message:**
-> "I don't recognize that model — want me to use `sas-find-resource-strategy` to confirm it exists,
-> or `model-info` to check its required inputs first?"
-
----
-
-## Step 2 — Prepare the scenario data
-
-**For a single record** (one object):
-```javascript
-scenario = { field1: value1, field2: value2, ... }
-```
-
-**For batch scoring** (multiple records — the typical case):
-```javascript
-scenario = [
-  { field1: val1, field2: val2, ... },
-  { field1: val3, field2: val4, ... },
-  ...
-]
-```
-
-**Critical rules:**
-- Loop or call sas-score-model-score **once per row**.
-- Field names in the scenario must match the model's expected input variable names **exactly**.
-  - If table column names differ from model input names, **flag this to the user** and ask for confirmation before scoring.
-  - Example: Table has `age_years`, but model expects `age` → ask user which column maps to which input.
-- Do not add units, labels, or extra metadata — raw field values only.
-
----
-
-## Step 3 — Invoke the appropriate scoring tool
-
-Based on the type extracted from the model name, invoke the corresponding tool:
-
-**For `.mas` (default):**
-```javascript
-sas-score-model-score({
-  model: "<modelname>",
-  scenario: scenario,  // object or array
-  uflag: false         // set true if you need field names prefixed with _
-})
-```
-
-**For `.job`:**
-```javascript
-sas-score-run-job({
-  name: "<jobname>",
-  scenario: scenario
-})
-```
-
-**For `.jobdef`:**
-```javascript
-sas-score-run-jobdef({
-  name: "<jobdefname>",
-  scenario: scenario
-})
-```
-
-**For `.scr`:**
-```javascript
-sas-score-scr-score({
-  url: "<scr_endpoint_url>",
-  scenario: scenario
-})
-```
-
-**For `.sas`:**
-```javascript
-sas-score-run-sas-program({
-  src: "<sas_or_sql_code>",
-  scenario: scenario
-})
-```
-
-**Rules:**
-- Pass the full batch in one call; do not loop over rows
-- If scoring fails, return the structured error and suggest troubleshooting
-- For MAS models, include uflag parameter if underscore-prefixed output is needed
-- For jobs/jobdefs, scenario becomes parameter arguments
-- For SCR, include full URL endpoint
-
----
-
-## Step 4 — Present the results
-
-Merge the scoring output back with the input records and present as a table where possible.
-
-**Always surface:**
-- The key prediction/score field(s) (e.g. `P_churn`, `score`, `prediction`, `P_risk`)
-- Any probability/confidence fields for classification models (e.g. `P_class0`, `P_class1`)
-- Selected input fields that drove the prediction, so the user can see context
-
-**Formatting:**
-- Present results in a table for clarity
-- If results exceed 10 rows, show the first 10 and ask: *"Want to see more results or export the full set?"*
-- Round numeric predictions to 2–4 decimal places for readability
-
----
-
-## Common flows
-
-**Flow A — Score rows with MAS model**
-> "Score the first 10 customers in Public.customers with the churn model"
-
-1. `sas-score-read-table` → { table: "Public.customers", limit: 10 }
-2. `sas-score-model-score` → { model: "churn", scenario: [ ...10 row objects ] }
-3. Present merged results with prediction + key inputs
-
-**Flow B — Score with a scoring job**
-> "Score December sales with the monthly_scorer job using month=12,year=2025"
-
-1. `sas-score-run-job` → { name: "monthly_scorer", scenario: { month: "12", year: "2025" } }
-2. Capture job output and tables
-3. Present results
-
-**Flow C — Score with a job definition**
-> "Run fraud detection jobdef on transaction amount=500, merchant=online"
-
-1. `sas-score-run-jobdef` → { name: "fraud_detection", scenario: { amount: "500", merchant: "online" } }
-2. Capture log, listings, and tables
-3. Present results
-
-**Flow D — Score with SCR endpoint**
-> "Score with the loan model at https://scr-host/models/loan using age=45, credit_score=700"
-
-1. `sas-score-scr-score` → { url: "https://scr-host/models/loan", scenario: { age: "45", credit_score: "700" } }
-2. Capture prediction response
-3. Present result
-
-**Flow E — Score results of an analytical query with MAS**
-> "Score high-value customers (spend > 5000) in mylib.sales with the fraud model"
-
-1. `sas-score-sas-query` → { table: "mylib.sales", sql: "SELECT * FROM mylib.sales WHERE spend > 5000" }
-2. `sas-score-model-score` → { model: "fraud", scenario: [ ...result rows ] }
-3. Present merged results
-
-**Flow F — User supplies scenario data directly**
-> "Score age=45, income=60000, region=South with the churn model"
-
-1. Skip read step
-2. `sas-score-model-score` → { model: "churn", scenario: { age: "45", income: "60000", region: "South" } }
-3. Present result
-
-**Flow G — Model unfamiliar, need to confirm**
-> "Score Public.applicants with the creditRisk2 model"
-
-1. Pause — "creditRisk2" is new
-2. Suggest: `sas-find-resource-strategy` to confirm resource existence, `model-info` to get input variables
-3. Once confirmed → `sas-score-read-table` + `sas-score-model-score`
-
-**Flow H — Generic score syntax with type routing**
-> "score with model churn.mas scenario =age=45,income=60000"
-> "score fraud_detector.jobdef where scenario =amount=500"
-> "score monthly_report.job using month=10,year=2025"
-
-1. Parse model name to extract type (.mas, .job, .jobdef, .scr, .sas)
-2. Route to appropriate tool based on type
-3. Parse scenario and invoke tool with parameters
-4. Present results from routed tool
-
----
-
-## Error handling
-
-| Problem | Action |
-|---|---|
-| Model not found | Use `sas-find-resource-strategy` to verify the model (or job/jobdef type) exists |
-| Input field name mismatch | Show the mismatch (table has X, model expects Y), ask user to confirm mapping |
-| 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 |
-
----
-
-## Tips
-
-- **Batch is better:** Always pass the full set of records in one `sas-score-model-score` call. Do not loop.
-- **Confirm mappings:** If column names don't match model inputs, ask before scoring.
-- **Show context:** Include key input columns in the result output so predictions make sense.
-- **Limit output:** For large result sets (>10 rows), ask before showing all.
-
----
-
-## Integration with other skills
-
-- **Before scoring table data**: Use `sas-find-resource-strategy` to verify resources, then `sas-read-strategy` to fetch records
-- **For read + score workflows**: Use `sas-read-and-score-strategy` for the complete end-to-end pattern

package/scripts/optimize_final.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python3
-import re
-
-# Read and replace listJobs
-with open('src/toolSet/listJobs.js', 'r') as f:
-    content = f.read()
-
-# Find and replace listJobs description - find the full description block
-pattern = r'let description = `\n  ## list-jobs.*?  `;'
-replacement = r'''let description = `
-list-jobs — enumerate SAS Viya job assets.
-
-USE when: list jobs, show jobs, browse jobs, list available jobs, next page of jobs
-DO NOT USE for: find single job (use find-job), execute job (use run-job), run jobdef (use run-jobdef), sas code (use run-sas-program)
-
-PARAMETERS
-- limit: number (default: 10) — number of jobs per page
-- start: number (default: 1) — 1-based page offset
-- where: string (default: '') — optional filter expression
-
-ROUTING RULES
-- "list jobs" → { start: 1, limit: 10 }
-- "show me 25 jobs" → { start: 1, limit: 25 }
-- "list jobs limit 50" → { start: 1, limit: 50 }
-- "next jobs" (after prior page) → { start: previousStart + previousLimit, limit: previousLimit }
-
-EXAMPLES
-- "list jobs" → { start: 1, limit: 10 }
-- "list 25 jobs" → { start: 1, limit: 25 }
-- "next jobs" → { start: 11, limit: 10 }
-
-NEGATIVE EXAMPLES (do not route here)
-- "find job abc" (use find-job)
-- "run job abc" (use run-job)
-- "list models" (use list-models)
-
-PAGINATION
-If returned length === limit, hint: next start = start + limit. Empty result with start > 1 means paged past end.
-
-ERRORS
-Surface backend error directly; never fabricate job names.
-  `;'''
-
-if re.search(pattern, content, re.DOTALL):
-    content = re.sub(pattern, replacement, content, flags=re.DOTALL)
-    with open('src/toolSet/listJobs.js', 'w') as f:
-        f.write(content)
-    print("✓ Updated listJobs.js")
-else:
-    print("✗ Pattern not found in listJobs.js")
-
-# Read and replace listJobdefs  
-with open('src/toolSet/listJobdefs.js', 'r') as f:
-    content = f.read()
-
-pattern = r'let description = `\n  ## list-jobdefs.*?  `;'
-replacement = r'''let description = `
-list-jobdefs — enumerate SAS Viya job definitions (jobdefs) assets.
-
-USE when: list jobdefs, show jobdefs, browse jobdefs, list available jobdefs, next page
-DO NOT USE for: find single jobdef (use find-jobdef), execute jobdef (use run-jobdef), find job (use find-job), sas code (use run-sas-program)
-
-PARAMETERS
-- limit: number (default: 10) — number of jobdefs per page
-- start: number (default: 1) — 1-based page offset
-- where: string (default: '') — optional filter expression
-
-ROUTING RULES
-- "list jobdefs" → { start: 1, limit: 10 }
-- "show me 25 jobdefs" → { start: 1, limit: 25 }
-- "next jobdefs" → { start: previousStart + previousLimit, limit: previousLimit }
-
-EXAMPLES
-- "list jobdefs" → { start: 1, limit: 10 }
-- "list 25 jobdefs" → { start: 1, limit: 25 }
-- "next jobdefs" → { start: 11, limit: 10 }
-
-NEGATIVE EXAMPLES (do not route here)
-- "find jobdef abc" (use find-jobdef)
-- "list jobs" (use list-jobs)
-- "run jobdef abc" (use run-jobdef)
-
-PAGINATION
-If returned length === limit, hint: next start = start + limit.
-
-ERRORS
-Surface backend error directly; never fabricate jobdef names.
-  `;'''
-
-if re.search(pattern, content, re.DOTALL):
-    content = re.sub(pattern, replacement, content, flags=re.DOTALL)
-    with open('src/toolSet/listJobdefs.js', 'w') as f:
-        f.write(content)
-    print("✓ Updated listJobdefs.js")
-else:
-    print("✗ Pattern not found in listJobdefs.js")
-
-# Read and replace runCasProgram
-with open('src/toolSet/runCasProgram.js', 'r') as f:
-    content = f.read()
-
-pattern = r'let description = `\n## run-cas-program.*?Response\n`'
-replacement = r'''let description = `
-run-cas-program — execute a CAS program on SAS Viya server.
-
-USE when: run cas program, execute cas, submit cas, run cas code, cas action
-DO NOT USE for: macros (use run-macro), sas code (use run-sas-program), jobs (use run-job/find-job), jobdefs (use run-jobdef/find-jobdef), models (use find-model)
-
-PARAMETERS
-- src: string (required) — CAS program code to execute verbatim
-- scenario: string | object (optional) — input parameters. Accepts: "x=1, y=2" or {x:1, y:2}
-
-ROUTING RULES
-- "run cas program 'action echo / code=\"xyz\"'" → { src: "action echo / code=\"xyz\"" }
-- "submit cas action echo" → { src: "action echo" }
-- "cas program with param1=10" → { src: "...", scenario: {param1: 10} }
-
-EXAMPLES
-- "run cas program 'action echo / code=\"hello\"'" → { src: "action echo / code=\"hello\"" }
-- "execute cas action simple.summary" → { src: "action simple.summary" }
-
-NEGATIVE EXAMPLES (do not route here)
-- "run sas macro" (use run-macro)
-- "submit sas code" (use run-sas-program)
-- "run job X" (use run-job)
-
-NOTES
-Sends src verbatim without validation. For SAS macros use run-macro. For arbitrary SAS code use run-sas-program.
-
-RESPONSE
-Log output, listings, tables from CAS execution. Error if execution fails.
-`'''
-
-if re.search(pattern, content, re.DOTALL):
-    content = re.sub(pattern, replacement, content, flags=re.DOTALL)
-    with open('src/toolSet/runCasProgram.js', 'w') as f:
-        f.write(content)
-    print("✓ Updated runCasProgram.js")
-else:
-    print("✗ Pattern not found in runCasProgram.js")

package/scripts/optimize_tools.py

@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-import re
-
-# DevaScore optimization
-deva_old = '''    let description = `
-## deva-score — compute a numeric score based on two input values
-
-LLM Invocation Guidance (When to use)
-Use THIS tool when:
-- User wants to calculate the deva score: "Calculate deva score for 5 and 10"
-- User provides two numbers for scoring: "Score these values: 3 and 7"
-- User wants to compute a score in a series: "Calculate scores for [list of numbers]"
-
-Do NOT use this tool for:
-- Scoring models (use model-score)
-- Statistical calculations beyond deva scoring
-- Looking up data or metadata
-
-Purpose
-Compute a numeric deva score by applying the formula (a + b) * 42 to two input numbers. For scoring more than two numbers, call this tool multiple times using the previous result as the first input (left-to-right fold).
-
-Parameters
-- a (number, required): First numeric input value
-- b (number, required): Second numeric input value
-
-Response Contract
-Returns a numeric result: (a + b) * 42
-The result is always a number representing the computed deva score.
-
-Disambiguation & Clarification
-- If user provides more than two numbers without clear instructions: "Do you want to calculate the deva score by combining these numbers left-to-right?"
-- If user provides non-numeric input: "Please provide numeric values"
-
-Examples (→ mapped params)
-- "Calculate deva score for 5 and 10" → { a: 5, b: 10 } returns 630
-- "Score 1 and 2" → { a: 1, b: 2 } returns 126
-- For multiple numbers, chain calls: devaScore(1,2)→126, then devaScore(126,3)→5418
-
-Negative Examples (should NOT call deva-score)
-- "Score this customer with the credit model" (use model-score instead)
-- "Calculate the mean of these values" (use run-sas-program or sas-query instead)
-
-Related Tools
-- None directly related (this is a specialized scoring tool)
-
-Notes
-For sequences of numbers, use a left-to-right fold: call devaScore(first, second), then use that result as the first parameter for devaScore(result, third), and so on.
-`;'''
-
-deva_new = '''    let description = `
-deva-score — compute a numeric score based on two input values.
-
-USE when: calculate deva score, score these values, compute score for numbers
-DO NOT USE for: model scoring (use model-score), statistical calculations, data lookup
-
-PARAMETERS
-- a: number (required) — first input value
-- b: number (required) — second input value
-
-FORMULA: (a + b) * 42
-
-ROUTING RULES
-- "calculate deva score for 5 and 10" → { a: 5, b: 10 }
-- "score 1 and 2" → { a: 1, b: 2 }
-- "deva score a=3, b=7" → { a: 3, b: 7 }
-- Multiple numbers → chain calls left-to-right: call(first, second), then call(result, third)
-
-EXAMPLES
-- "Calculate deva score for 5 and 10" → { a: 5, b: 10 } returns 630
-- "Score 1 and 2" → { a: 1, b: 2 } returns 126
-- "Deva score 20 and 30" → { a: 20, b: 30 } returns 2100
-
-NEGATIVE EXAMPLES (do not route here)
-- "Score this customer with credit model" (use model-score)
-- "Calculate the mean of these values" (use run-sas-program or sas-query)
-- "Statistical analysis of numbers" (use sas-query)
-
-RESPONSE
-Returns { score: (a + b) * 42 }
-    `;'''
-
-files = {
-    'src/toolSet/devaScore.js': (deva_old, deva_new),
-}
-
-for filepath, (old, new) in files.items():
-    try:
-        with open(filepath, 'r', encoding='utf-8') as f:
-            content = f.read()
-        
-        if old in content:
-            content = content.replace(old, new)
-            with open(filepath, 'w', encoding='utf-8') as f:
-                f.write(content)
-            print(f"✓ Updated {filepath}")
-        else:
-            print(f"✗ Pattern not found in {filepath}")
-    except Exception as e:
-        print(f"✗ Error updating {filepath}: {e}")

package/scripts/setup-skills.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import os from 'os';
-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);
-// 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 => {
-        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);
-}
-process.exit(0);