nowaikit 2.5.3 → 3.0.0

package/dist/prompts/capabilities/build-catalog.js

@@ -0,0 +1,350 @@
+const capability = {
+    name: 'build-catalog',
+    title: 'Build Catalog Item',
+    description: 'End-to-end catalog item creation — variables, UI policies, client scripts, approval rules, fulfillment workflow',
+    category: 'build',
+    arguments: [
+        {
+            name: 'description',
+            description: 'what the catalog item should provide / what users are requesting',
+            required: true,
+        },
+        {
+            name: 'category',
+            description: 'catalog category (e.g., Hardware, Software, Access, Services)',
+            required: false,
+        },
+        {
+            name: 'fulfillment_type',
+            description: 'flow, workflow, approval_only. Default: flow',
+            required: false,
+        },
+    ],
+    recommendedTools: [
+        'query_records',
+        'list_catalog_items',
+        'get_catalog_item',
+        'create_catalog_item',
+        'create_catalog_variable',
+        'create_catalog_ui_policy',
+        'create_approval_rule',
+        'create_flow',
+        'get_table_schema',
+    ],
+    buildPrompt(args = {}) {
+        const desc = args.description ?? '<not provided>';
+        const category = args.category ?? '<not specified>';
+        const fulfillmentType = args.fulfillment_type ?? 'flow';
+        return [
+            {
+                role: 'assistant',
+                content: {
+                    type: 'text',
+                    text: [
+                        '# Capability: Build Catalog Item',
+                        '',
+                        '## ServiceNow Service Catalog — Platform Knowledge',
+                        '',
+                        '### Catalog Item Architecture',
+                        '- **Catalog Item** (`sc_cat_item`): the requestable service. Contains metadata (name, description, category, price, picture), variables, workflows, and policies.',
+                        '- **Category** (`sc_category`): organizational hierarchy for catalog items. Supports nesting (parent → child categories).',
+                        '- **Variables** (`item_option_new`): form fields on the catalog item. Typed, ordered, and can be mandatory/optional.',
+                        '- **Variable Sets** (`item_option_new_set`): reusable groups of variables shared across multiple catalog items.',
+                        '- **Catalog Client Scripts** (`catalog_script_client`): JavaScript that runs on the catalog form (onChange, onLoad, onSubmit). Separate from standard client scripts.',
+                        '- **Catalog UI Policies** (`catalog_ui_policy`): declarative show/hide/mandatory/read-only rules for catalog variables.',
+                        '- **Approval Rules** or flows that govern the approval process.',
+                        '- **Fulfillment** via Flow Designer, Legacy Workflow, or manual task creation.',
+                        '',
+                        '### Request Model (REQ / RITM / TASK)',
+                        '- **Request (REQ)** (`sc_request`): the parent container for one or more ordered items. Created when the user submits the cart.',
+                        '- **Requested Item (RITM)** (`sc_req_item`): one per catalog item ordered. Contains the variable values the user submitted. Tracks fulfillment state.',
+                        '- **Catalog Task (SCTASK)** (`sc_task`): sub-tasks under a RITM for fulfillment steps (e.g., "Provision Access", "Ship Hardware"). Assigned to fulfillment groups.',
+                        '- **Execution Plan:** defines the task sequence for fulfillment — parallel, sequential, or conditional task generation.',
+                        '',
+                        '### Variable Types',
+                        '- **Single Line Text:** free-text input. Max length configurable. Supports regex validation.',
+                        '- **Multi Line Text:** textarea for longer input.',
+                        '- **Select Box (Choice):** dropdown with predefined choices. Choices defined inline or from a choice table.',
+                        '- **Lookup Select Box:** dropdown with choices from a GlideRecord query (filtered, dynamic).',
+                        '- **Reference:** reference to a record on another table (e.g., sys_user, cmdb_ci). Supports reference qualifiers.',
+                        '- **Checkbox:** boolean true/false.',
+                        '- **CheckBox (Yes/No):** explicit Yes/No label checkboxes.',
+                        '- **Date / Date-Time:** date picker with configurable format.',
+                        '- **Email / URL / IP Address:** text with built-in format validation.',
+                        '- **Numeric Scale:** slider or numeric input with min/max/step.',
+                        '- **Masked:** password-style masked input for sensitive data.',
+                        '- **List Collector:** multi-select from a reference table (e.g., select multiple users).',
+                        '- **Multi-Row Variable Set (MRVS):** table-like input where users add multiple rows of structured data (e.g., multiple software titles, multiple users). Each row has its own variables.',
+                        '- **Container Start / Container End / Container Split:** layout controls for grouping variables visually.',
+                        '- **Label / Break / Macro:** display-only elements for instructions, spacing, or custom UI.',
+                        '',
+                        '### Variable Attributes',
+                        '- `ref_qual_elements`: reference qualifier for Reference variables (JavaScript function or encoded query).',
+                        '- `max_length`: character limit for text fields.',
+                        '- `default_value`: pre-populated value.',
+                        '- `tooltip`: help text shown on hover.',
+                        '- `read_only`: prevents user modification.',
+                        '- `hidden`: hides the variable (still submitted).',
+                        '- `mandatory`: requires a value before submission.',
+                        '- `order`: display order (lower = higher on form).',
+                        '- `question_text`: the label shown to the user.',
+                        '- `help_text`: additional guidance shown in a help popover.',
+                        '',
+                        '### Catalog Client Script Patterns',
+                        '- **onChange:** `function onChange(control, oldValue, newValue, isLoading) { ... }`. Trigger field specified in script configuration.',
+                        '- **onLoad:** `function onLoad() { ... }`. Runs when the catalog form loads.',
+                        '- **onSubmit:** `function onSubmit() { ... return true; }`. Return `false` to prevent submission.',
+                        '- Use `g_form.getControl(variableName)` to access DOM elements of catalog variables.',
+                        '- Use `g_form.setValue(variableName, value)` / `g_form.getValue(variableName)` for variable values.',
+                        '- Use `g_form.setDisplay(variableName, true/false)` to show/hide variables programmatically.',
+                        '- Use `g_form.setMandatory(variableName, true/false)` for dynamic mandatory rules.',
+                        '- Use GlideAjax for server-side lookups (same pattern as standard client scripts but targeting catalog Script Includes).',
+                        '',
+                        '### Approval Engines',
+                        '- **Approval Rules** (`sysapproval_approver`): condition-based rules that create approval records. Conditions based on RITM field values.',
+                        '- **Approval Group:** set an approval group on the catalog item — all members must approve (or configure "anyone").',
+                        '- **Manager Approval:** use `requested_for.manager` to route to the requester\'s manager.',
+                        '- **Multi-Level Approval:** chain approval rules (Level 1 → Level 2) using "approval for" relationships or flow-based approval sequences.',
+                        '- **Auto-Approve:** skip approval for certain roles or dollar thresholds using conditions.',
+                        '- **Rejection Handling:** define what happens on rejection — cancel RITM, notify requester, allow resubmission.',
+                        '',
+                        '### Fulfillment Options',
+                        '- **Flow Designer (recommended):** create a flow triggered by RITM creation/approval. Use flow actions to create tasks, send notifications, provision resources. Supports error handling, subflows, approval steps.',
+                        '- **Legacy Workflow:** older visual workflow engine. Still functional but being replaced by Flow Designer.',
+                        '- **Execution Plan:** define catalog tasks with assignment rules, SLA, and sequencing. Simpler than flows for basic task-based fulfillment.',
+                        '- **Approval Only:** no fulfillment automation — after approval, the RITM is manually handled by fulfillment groups.',
+                        '',
+                        '### Pricing & Cost',
+                        '- `price`: the price shown to the user (informational or chargeback).',
+                        '- `recurring_price`: for subscription-style items.',
+                        '- `cost`: internal cost (not shown to users). Used for budgeting.',
+                        '- Variables can contribute to dynamic pricing via `price_if_checked` attribute.',
+                        '',
+                        '---',
+                        '',
+                        `Starting catalog item build for: **${desc}**`,
+                        category !== '<not specified>'
+                            ? `Category: **${category}**`
+                            : 'Category: to be determined from requirement analysis',
+                        `Fulfillment type: **${fulfillmentType}**`,
+                    ].join('\n'),
+                },
+            },
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Build an end-to-end catalog item for the following requirement:`,
+                        `**Requirement:** ${desc}`,
+                        `**Category:** ${category}`,
+                        `**Fulfillment type:** ${fulfillmentType}`,
+                        '',
+                        'Follow these steps exactly:',
+                        '',
+                        '### Step 1 — Understand the Requirement',
+                        'Analyze the requirement and determine:',
+                        '- **What service** is being offered — what does the end user receive when the request is fulfilled.',
+                        '- **Who can request** — all users, specific roles, specific departments, specific locations.',
+                        '- **What data is needed** — what information must the requester provide (justification, manager approval, asset selection, etc.).',
+                        '- **Approval path** — who approves and under what conditions. Is auto-approval possible for certain scenarios.',
+                        '- **Fulfillment steps** — what actions are performed after approval (provision access, ship hardware, create account, assign license).',
+                        '- **SLA expectations** — how quickly should the request be fulfilled.',
+                        category !== '<not specified>'
+                            ? `- **Category:** ${category}. Verify this category exists using **query_records** on sc_category.`
+                            : '- **Category:** determine the appropriate category. Use **query_records** on sc_category to find existing categories.',
+                        '',
+                        '### Step 2 — Check Existing Catalog Items',
+                        'Use **list_catalog_items** to find similar items:',
+                        '- Items with similar names or descriptions.',
+                        '- Items in the same category that might overlap.',
+                        '- Items that could be extended or cloned instead of building from scratch.',
+                        '- Variable sets that are already shared across items and could be reused.',
+                        '',
+                        'If a very similar item exists, recommend whether to modify it, clone it, or create a new one.',
+                        '',
+                        '### Step 3 — Design Variable Layout',
+                        'Plan all variables the catalog form needs:',
+                        '',
+                        '```',
+                        'CATALOG ITEM: [Name]',
+                        '  VARIABLES:',
+                        '    --- Container: "Request Details" ---',
+                        '    1. variable_name (Type) [mandatory?] — description',
+                        '       Attributes: default, ref_qual, tooltip',
+                        '    2. ...',
+                        '    --- Container End ---',
+                        '    ',
+                        '    --- Variable Set: "Common Fields" (reuse existing if available) ---',
+                        '    3. ...',
+                        '    --- Variable Set End ---',
+                        '    ',
+                        '    --- MRVS: "Items" (if multi-row needed) ---',
+                        '    4. row_field_1 (Type) — description',
+                        '    5. row_field_2 (Type) — description',
+                        '    --- MRVS End ---',
+                        '```',
+                        '',
+                        'For each variable, specify:',
+                        '- **Name:** snake_case, descriptive.',
+                        '- **Question text:** user-facing label.',
+                        '- **Type:** Single Line Text, Select Box, Reference, Checkbox, Date, MRVS, etc.',
+                        '- **Mandatory:** yes/no (consider making fields conditionally mandatory via UI policies).',
+                        '- **Order:** display order (use increments of 100 for easy insertion).',
+                        '- **Default value:** pre-populate if appropriate.',
+                        '- **Help text / Tooltip:** guidance for the requester.',
+                        '- **Reference qualifier:** for Reference variables, define the filter (e.g., "active=true^department=IT").',
+                        '- **Validation:** regex pattern for text fields, min/max for numeric fields.',
+                        '',
+                        'Use **create_catalog_variable** for each variable.',
+                        '',
+                        '### Step 4 — Create UI Policies',
+                        'Define declarative rules for dynamic form behavior:',
+                        '',
+                        'For each UI policy, specify:',
+                        '- **Condition:** when the policy applies (e.g., `variable_type == "Hardware"`).',
+                        '- **Actions:** show/hide, mandatory/not mandatory, read-only/editable for target variables.',
+                        '- **Reverse if false:** whether to reverse the actions when the condition is no longer met.',
+                        '- **On load:** whether to evaluate on initial form load.',
+                        '',
+                        'Common patterns:',
+                        '- Show additional fields when a category or type is selected.',
+                        '- Make justification mandatory when cost exceeds a threshold.',
+                        '- Hide approval-related fields from non-approver users.',
+                        '- Show/hide MRVS based on a checkbox or select value.',
+                        '',
+                        'Use **create_catalog_ui_policy** for each policy.',
+                        '',
+                        '### Step 5 — Create Catalog Client Scripts',
+                        'For dynamic behavior that UI policies cannot express:',
+                        '',
+                        '**onChange scripts:**',
+                        '- Populate dependent fields based on a selection (e.g., selecting a CI populates its location and support group).',
+                        '- Calculate estimated cost based on variable selections.',
+                        '- Dynamic reference qualifier updates.',
+                        '- Use GlideAjax for server-side lookups (do NOT use synchronous GlideRecord on the client).',
+                        '',
+                        '**onLoad scripts:**',
+                        '- Pre-populate variables from URL parameters or user profile.',
+                        '- Set dynamic defaults based on the requester\'s department, location, or role.',
+                        '- Initialize complex variable interactions.',
+                        '',
+                        '**onSubmit scripts:**',
+                        '- Client-side validation that is too complex for UI policies (cross-variable validation, date range checks).',
+                        '- Confirmation dialogs for high-impact requests.',
+                        '- Always back up client validation with server-side validation (client scripts can be bypassed).',
+                        '',
+                        'For each script, generate the code and use the appropriate creation tool. If GlideAjax is needed, create the corresponding client-callable Script Include.',
+                        '',
+                        '### Step 6 — Design Approval Workflow',
+                        'Define the approval chain based on the requirement:',
+                        '',
+                        '**Approval Design:**',
+                        '- **Level 1:** [who approves] — [condition for this level].',
+                        '- **Level 2 (if needed):** [who approves] — [condition].',
+                        '- **Auto-approve conditions:** [when approval is skipped].',
+                        '- **Rejection handling:** [what happens when rejected — cancel, allow resubmission, notify].',
+                        '- **Escalation:** [what happens if approval is not acted on within SLA — remind, escalate to manager\'s manager].',
+                        '',
+                        'Common approval patterns:',
+                        '- **Manager approval:** route to `requested_for.manager`. Simple, works for most HR/IT requests.',
+                        '- **Group approval:** route to a specific group (e.g., "IT Security Approvers"). Use when specialized knowledge is needed.',
+                        '- **Cost-based:** auto-approve below $X, manager approval $X-$Y, VP approval above $Y.',
+                        '- **Role-based bypass:** users with `catalog_admin` role skip approval.',
+                        '',
+                        'Use **create_approval_rule** for each approval level.',
+                        '',
+                        '### Step 7 — Create Fulfillment Flow',
+                        `Fulfillment type: **${fulfillmentType}**.`,
+                        '',
+                        fulfillmentType === 'flow'
+                            ? [
+                                'Create a Flow Designer flow triggered by RITM approval:',
+                                '',
+                                '1. **Trigger:** Record update on `sc_req_item` when `approval = approved` and `stage = waiting_for_approval → fulfillment`.',
+                                '2. **Read variables:** extract variable values from the RITM for use in fulfillment actions.',
+                                '3. **Create fulfillment tasks (SCTASK):**',
+                                '   - One task per fulfillment step (e.g., "Provision Account", "Ship Hardware", "Configure Software").',
+                                '   - Assign to appropriate fulfillment groups.',
+                                '   - Set SLA on each task.',
+                                '   - Include variable values in task description for fulfiller reference.',
+                                '4. **Send notifications:**',
+                                '   - Notify requester that their request is being fulfilled.',
+                                '   - Notify fulfillers of new tasks.',
+                                '5. **Completion logic:**',
+                                '   - When all tasks are closed, close the RITM.',
+                                '   - Send fulfillment confirmation to requester.',
+                                '6. **Error handling:**',
+                                '   - Try/catch around provisioning steps.',
+                                '   - On failure: notify support, update RITM work notes, do NOT close the RITM.',
+                                '',
+                                'Use **create_flow** to build the fulfillment flow.',
+                            ].join('\n')
+                            : fulfillmentType === 'workflow'
+                                ? [
+                                    'Design a legacy workflow for fulfillment:',
+                                    '',
+                                    '- Triggered on RITM approval.',
+                                    '- Create catalog tasks with assignment rules.',
+                                    '- Include approval activities if multi-stage approval is needed.',
+                                    '- Add notification activities for requester and fulfillers.',
+                                    '- Include error handling with "Run Script" activities for complex logic.',
+                                    '',
+                                    'Note: Flow Designer is recommended for new development. Consider using Flow Designer instead.',
+                                ].join('\n')
+                                : [
+                                    'No automated fulfillment — approval only:',
+                                    '',
+                                    '- After approval, the RITM moves to "Open" state for manual handling.',
+                                    '- Ensure the RITM assignment group is set so fulfillers know to pick it up.',
+                                    '- Add a notification to alert the fulfillment group when a new approved RITM is ready.',
+                                ].join('\n'),
+                        '',
+                        '### Step 8 — Create the Catalog Item',
+                        'Use **create_catalog_item** with:',
+                        '- Name, description, short description.',
+                        '- Category assignment.',
+                        '- Price (if applicable).',
+                        '- Availability (active, visible on portal).',
+                        '- Icon/picture.',
+                        '- All variables, UI policies, and client scripts linked.',
+                        '- Fulfillment flow/workflow associated.',
+                        '',
+                        'Report the sys_id of the created catalog item and all associated artifacts:',
+                        '',
+                        '| Artifact | Type | sys_id | Name |',
+                        '|----------|------|--------|------|',
+                        '| Catalog Item | sc_cat_item | ... | ... |',
+                        '| Variable 1 | item_option_new | ... | ... |',
+                        '| Variable 2 | item_option_new | ... | ... |',
+                        '| UI Policy 1 | catalog_ui_policy | ... | ... |',
+                        '| Client Script 1 | catalog_script_client | ... | ... |',
+                        '| Approval Rule | sysapproval_approver | ... | ... |',
+                        '| Fulfillment Flow | sys_hub_flow | ... | ... |',
+                        '',
+                        '### Step 9 — Suggest Test Scenarios',
+                        'Provide a comprehensive test matrix covering the full request lifecycle:',
+                        '',
+                        '| # | Scenario | Setup | Steps | Expected Result |',
+                        '|---|----------|-------|-------|-----------------|',
+                        '',
+                        'Include at minimum:',
+                        '- **Order happy path:** user opens catalog → fills variables → submits → approval requested → approved → tasks created → tasks completed → RITM closed → user notified.',
+                        '- **Variable validation:** submit with missing mandatory fields, invalid formats, boundary values. Verify error messages are shown.',
+                        '- **UI policy behavior:** change variable values to trigger each UI policy. Verify show/hide/mandatory/read-only states change correctly.',
+                        '- **Client script behavior:** trigger each onChange/onLoad/onSubmit script. Verify GlideAjax lookups return correct data.',
+                        '- **Approval path:** test with different requesters (different managers) and different variable values (different cost tiers) to verify routing.',
+                        '- **Rejection path:** approve at level 1, reject at level 2 (if multi-level). Verify RITM state, requester notification, and resubmission flow.',
+                        '- **Fulfillment:** verify each catalog task is created with correct assignment, description, and SLA.',
+                        '- **Task completion:** close all tasks and verify RITM auto-closes with correct state.',
+                        '- **Error path:** simulate fulfillment failure. Verify error handling, notifications, and RITM state.',
+                        '- **Role-based access:** verify the catalog item is visible only to authorized users/roles.',
+                        '- **Portal rendering:** verify the catalog item renders correctly in Service Portal (variable layout, UI policies, client scripts).',
+                    ].join('\n'),
+                },
+            },
+        ];
+    },
+};
+export default capability;
+//# sourceMappingURL=build-catalog.js.map

package/dist/prompts/capabilities/build-catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-catalog.js","sourceRoot":"","sources":["../../../src/prompts/capabilities/build-catalog.ts"],"names":[],"mappings":"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"}

package/dist/prompts/capabilities/build-client-script.d.ts

@@ -0,0 +1,4 @@
+import type { CapabilityDefinition } from '../types.js';
+declare const capability: CapabilityDefinition;
+export default capability;
+//# sourceMappingURL=build-client-script.d.ts.map

package/dist/prompts/capabilities/build-client-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-client-script.d.ts","sourceRoot":"","sources":["../../../src/prompts/capabilities/build-client-script.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,QAAA,MAAM,UAAU,EAAE,oBA4JjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/prompts/capabilities/build-client-script.js

@@ -0,0 +1,157 @@
+const capability = {
+    name: 'build-client-script',
+    title: 'Build Client Script',
+    description: 'Guided client script creation — onChange, onLoad, onSubmit with g_form/g_user best practices and GlideAjax patterns',
+    category: 'build',
+    arguments: [
+        {
+            name: 'description',
+            description: 'what the client script should do',
+            required: true,
+        },
+        {
+            name: 'table',
+            description: 'target table',
+            required: true,
+        },
+        {
+            name: 'type',
+            description: 'onChange, onLoad, onSubmit, onCellEdit. Default: onChange',
+            required: false,
+        },
+        {
+            name: 'field',
+            description: 'field name for onChange scripts',
+            required: false,
+        },
+    ],
+    recommendedTools: [
+        'create_client_script',
+        'list_client_scripts',
+        'get_client_script',
+        'create_ui_policy',
+        'get_table_schema',
+        'create_script_include',
+    ],
+    buildPrompt(args = {}) {
+        const desc = args.description ?? '<not provided>';
+        const table = args.table ?? '<not provided>';
+        const type = args.type ?? 'onChange';
+        const field = args.field ?? '<none specified>';
+        return [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        `Build a client script for the **${table}** table.`,
+                        `**Type:** ${type}`,
+                        `**Field:** ${field}`,
+                        `**Requirement:** ${desc}`,
+                        '',
+                        'Follow these steps exactly:',
+                        '',
+                        '### Step 1 — Decide: UI Policy vs Client Script',
+                        'Evaluate whether the requirement can be met with a **UI Policy** instead of a client script. Use a UI Policy if the behavior is purely:',
+                        '- Show / hide a field',
+                        '- Make a field mandatory / not mandatory',
+                        '- Make a field read-only / editable',
+                        '- Set a field value based on a simple condition',
+                        '',
+                        'If a UI Policy is sufficient, recommend that approach and use **create_ui_policy** instead. Explain the trade-offs (UI Policies are declarative, easier to maintain, and do not require scripting). Only proceed with a client script if the requirement involves complex logic, GlideAjax calls, or dynamic behavior that UI Policies cannot express.',
+                        '',
+                        '### Step 2 — Check Existing Client Scripts on the Table',
+                        `Use **list_client_scripts** filtered to table="${table}". Summarize active scripts in a table (name, type, field, order, description). Flag any that overlap with the new requirement or that run on the same field/event. Identify potential ordering conflicts.`,
+                        '',
+                        '### Step 3 — Check Table Schema',
+                        `Use **get_table_schema** for "${table}". Verify every field name used in the requirement exists. Note field types (reference fields need special handling with getDisplayValue/getReference). If the field argument is set to "${field}", confirm it exists and note its type.`,
+                        '',
+                        '### Step 4 — Generate the Script',
+                        `Generate the client script with the correct function signature for type **${type}**:`,
+                        '',
+                        '**onChange:**',
+                        '```javascript',
+                        'function onChange(control, oldValue, newValue, isLoading, isTemplate) {',
+                        '    if (isLoading || newValue === \'\') return;',
+                        '    // logic here',
+                        '}',
+                        '```',
+                        '',
+                        '**onLoad:**',
+                        '```javascript',
+                        'function onLoad() {',
+                        '    // logic here',
+                        '}',
+                        '```',
+                        '',
+                        '**onSubmit:**',
+                        '```javascript',
+                        'function onSubmit() {',
+                        '    // return false to abort submission',
+                        '    // logic here',
+                        '    return true;',
+                        '}',
+                        '```',
+                        '',
+                        '**onCellEdit:**',
+                        '```javascript',
+                        'function onCellEdit(sysIDs, table, oldValues, newValue, callback) {',
+                        '    // callback invocation is required',
+                        '    callback();',
+                        '}',
+                        '```',
+                        '',
+                        'Apply these best practices:',
+                        '- Always check `isLoading` and `isTemplate` in onChange to avoid running on form load.',
+                        '- Use `g_form.getReference(field, callback)` (async) instead of synchronous GlideRecord on the client.',
+                        '- Prefer `g_form.setValue()`, `g_form.setDisplay()`, `g_form.setMandatory()`, `g_form.setReadOnly()`.',
+                        '- Use `g_user.hasRole()` for client-side role checks (but never trust these for security).',
+                        '- Minimize DOM manipulation — use g_form APIs exclusively.',
+                        '- Include a JSDoc comment block: purpose, author, date.',
+                        '',
+                        '### Step 5 — GlideAjax Pattern (if needed)',
+                        'If the client script needs server-side data, generate a **GlideAjax** call AND the corresponding **Script Include**:',
+                        '',
+                        '**Client side:**',
+                        '```javascript',
+                        'var ga = new GlideAjax(\'MyScriptInclude\');',
+                        'ga.addParam(\'sysparm_name\', \'myMethod\');',
+                        'ga.addParam(\'sysparm_my_param\', value);',
+                        'ga.getXMLAnswer(function(answer) {',
+                        '    // handle response',
+                        '});',
+                        '```',
+                        '',
+                        '**Script Include (client-callable):**',
+                        '```javascript',
+                        'var MyScriptInclude = Class.create();',
+                        'MyScriptInclude.prototype = Object.extendsObject(AbstractAjaxProcessor, {',
+                        '    myMethod: function() {',
+                        '        var param = this.getParameter(\'sysparm_my_param\');',
+                        '        // server logic, return result',
+                        '        return JSON.stringify(result);',
+                        '    },',
+                        '    type: \'MyScriptInclude\'',
+                        '});',
+                        '```',
+                        '',
+                        'Use **create_script_include** to create it with `client_callable: true`. Report both artifacts.',
+                        '',
+                        '### Step 6 — Review for Security & Quality',
+                        'Audit the generated script:',
+                        '- **XSS:** Never inject unsanitized user input into DOM or g_form display values.',
+                        '- **Client-only validation is insufficient:** If onSubmit validates data, ensure a corresponding server-side business rule also validates (client scripts can be bypassed via API/import).',
+                        '- **Performance:** Avoid synchronous GlideRecord, excessive GlideAjax calls, or heavy DOM queries.',
+                        '- **Scoping:** Ensure the script works in both standard and workspace/agent views if applicable.',
+                        '- **Mobile:** Note if the script will NOT work on mobile/service portal (client scripts are form-view only).',
+                        '',
+                        '### Step 7 — Create the Artifact(s)',
+                        `Use **create_client_script** with the final script, table="${table}", type="${type}"${type === 'onChange' ? `, field="${field}"` : ''}. If a Script Include was generated in Step 5, create it as well. Report the sys_id(s) of all created artifacts.`,
+                    ].join('\n'),
+                },
+            },
+        ];
+    },
+};
+export default capability;
+//# sourceMappingURL=build-client-script.js.map

package/dist/prompts/capabilities/build-client-script.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-client-script.js","sourceRoot":"","sources":["../../../src/prompts/capabilities/build-client-script.ts"],"names":[],"mappings":"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"}

package/dist/prompts/capabilities/build-flow.d.ts

@@ -0,0 +1,4 @@
+import type { CapabilityDefinition } from '../types.js';
+declare const capability: CapabilityDefinition;
+export default capability;
+//# sourceMappingURL=build-flow.d.ts.map

package/dist/prompts/capabilities/build-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-flow.d.ts","sourceRoot":"","sources":["../../../src/prompts/capabilities/build-flow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,QAAA,MAAM,UAAU,EAAE,oBAmPjB,CAAC;AAEF,eAAe,UAAU,CAAC"}