newo 3.6.2 → 3.7.1

package/dist/lint/config.d.ts

@@ -0,0 +1,4 @@
+import type { NewoLintConfig } from 'newo-dsl-analyzer';
+export type { NewoLintConfig } from 'newo-dsl-analyzer';
+export declare function loadNewoLintConfig(startDir?: string): NewoLintConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/lint/config.js

@@ -0,0 +1,14 @@
+/**
+ * Lint config resolution for the newo CLI.
+ *
+ * Looks for `.neworc.yaml` / `.neworc.yml` / `.neworc.json` starting at
+ * the cwd and walking up to the filesystem root. Thin wrapper around
+ * newo-dsl-analyzer's `loadConfig` so consumers can override location
+ * per command if they need to.
+ */
+import path from 'path';
+import { loadConfig as analyzerLoadConfig } from 'newo-dsl-analyzer';
+export function loadNewoLintConfig(startDir = process.cwd()) {
+    return analyzerLoadConfig(path.resolve(startDir)) ?? {};
+}
+//# sourceMappingURL=config.js.map

package/dist/lint/discovery.d.ts

@@ -0,0 +1,34 @@
+import { type FormatVersion } from '../format/types.js';
+import type { CustomerConfig } from '../types.js';
+export interface DiscoveryOptions {
+    /** If set, restrict to one format's extensions only. */
+    format?: FormatVersion;
+    /** If true, include only files that hash-differ from `.newo/{customer}/hashes.json`. */
+    changedOnly?: boolean;
+    /** Additional absolute paths to skip. */
+    ignore?: string[];
+}
+export interface DiscoveredFile {
+    /** Absolute path on disk. */
+    absPath: string;
+    /** Path relative to the customer root (for display / reports). */
+    relPath: string;
+    /** Extension (including leading dot). */
+    ext: string;
+}
+/**
+ * Discover script files under a customer's tree.
+ * Respects format when given (else walks all recognized extensions).
+ */
+export declare function discoverCustomerFiles(customer: CustomerConfig, opts?: DiscoveryOptions): Promise<DiscoveredFile[]>;
+/**
+ * Discover files under an arbitrary directory.
+ * Used when the user passes explicit paths to `newo lint some/dir`.
+ */
+export declare function discoverFromPath(inputPath: string, opts?: DiscoveryOptions): Promise<DiscoveredFile[]>;
+/**
+ * Default root for lint invocations with no path arguments - the
+ * `newo_customers/` directory at the cwd.
+ */
+export declare function defaultRoot(): string;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/lint/discovery.js

@@ -0,0 +1,112 @@
+/**
+ * File discovery for `newo lint` / `newo format` / `newo check`.
+ *
+ * Walks a customer's tree (or any directory passed on the CLI), filters
+ * by format-aware extensions, and optionally narrows to files changed
+ * since the last push by consulting `.newo/{customer}/hashes.json`.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { NEWO_CUSTOMERS_DIR, customerDir } from '../fsutil.js';
+import { loadHashes } from '../hash.js';
+import { sha256 } from '../hash.js';
+import { ALL_SCRIPT_EXTENSIONS, CLI_V1_EXTENSIONS, NEWO_V2_EXTENSIONS, } from '../format/types.js';
+/**
+ * Discover script files under a customer's tree.
+ * Respects format when given (else walks all recognized extensions).
+ */
+export async function discoverCustomerFiles(customer, opts = {}) {
+    const root = customerDir(customer.idn);
+    if (!(await fs.pathExists(root)))
+        return [];
+    const exts = pickExtensions(opts.format);
+    const ignoreSet = new Set(opts.ignore ?? []);
+    const hits = await walkForExtensions(root, exts, ignoreSet);
+    if (!opts.changedOnly) {
+        return hits.map(absPath => toDiscoveredFile(absPath, root));
+    }
+    const stored = await loadHashes(customer.idn);
+    const changed = [];
+    for (const absPath of hits) {
+        const current = sha256(await fs.readFile(absPath, 'utf8'));
+        if (stored[absPath] !== current) {
+            changed.push(toDiscoveredFile(absPath, root));
+        }
+    }
+    return changed;
+}
+/**
+ * Discover files under an arbitrary directory.
+ * Used when the user passes explicit paths to `newo lint some/dir`.
+ */
+export async function discoverFromPath(inputPath, opts = {}) {
+    const abs = path.resolve(inputPath);
+    if (!(await fs.pathExists(abs)))
+        return [];
+    const exts = pickExtensions(opts.format);
+    const ignoreSet = new Set(opts.ignore ?? []);
+    const stat = await fs.stat(abs);
+    let hits;
+    if (stat.isFile()) {
+        hits = exts.includes(path.extname(abs)) ? [abs] : [];
+    }
+    else {
+        hits = await walkForExtensions(abs, exts, ignoreSet);
+    }
+    const root = stat.isDirectory() ? abs : path.dirname(abs);
+    return hits.map(p => toDiscoveredFile(p, root));
+}
+function pickExtensions(format) {
+    if (!format)
+        return [...ALL_SCRIPT_EXTENSIONS];
+    const map = format === 'newo_v2' ? NEWO_V2_EXTENSIONS : CLI_V1_EXTENSIONS;
+    return Object.values(map);
+}
+function toDiscoveredFile(absPath, root) {
+    return {
+        absPath,
+        relPath: path.relative(root, absPath),
+        ext: path.extname(absPath),
+    };
+}
+async function walkForExtensions(dir, exts, ignore) {
+    const out = [];
+    const stack = [dir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (ignore.has(current))
+            continue;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            // Skip hidden dirs, node_modules, and the .newo state directory.
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.name === 'node_modules')
+                continue;
+            const full = path.join(current, entry.name);
+            if (ignore.has(full))
+                continue;
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (exts.includes(path.extname(entry.name))) {
+                out.push(full);
+            }
+        }
+    }
+    return out.sort();
+}
+/**
+ * Default root for lint invocations with no path arguments - the
+ * `newo_customers/` directory at the cwd.
+ */
+export function defaultRoot() {
+    return NEWO_CUSTOMERS_DIR;
+}
+//# sourceMappingURL=discovery.js.map

package/dist/lint/live-schema.d.ts

@@ -0,0 +1,20 @@
+import type { CustomerConfig } from '../types.js';
+export interface LiveSchemaSnapshot {
+    actions: Array<{
+        name: string;
+        [k: string]: unknown;
+    }>;
+    fetchedAt: string;
+}
+export declare function liveSchemaCachePath(customerIdn: string): Promise<string>;
+/**
+ * Fetch the current action catalog from NEWO and cache it.
+ * Returns a snapshot ready to pass to `createLinter`.
+ */
+export declare function refreshLiveSchema(customer: CustomerConfig): Promise<LiveSchemaSnapshot>;
+/**
+ * Load the cached snapshot if present. Returns null when the cache is
+ * missing or corrupt (caller should fall back to bundled schemas).
+ */
+export declare function loadCachedLiveSchema(customerIdn: string): Promise<LiveSchemaSnapshot | null>;
+//# sourceMappingURL=live-schema.d.ts.map

package/dist/lint/live-schema.js

@@ -0,0 +1,52 @@
+/**
+ * Live schema refresh: hits `/api/v1/script/actions` via the existing
+ * NEWO api client, caches the response to `.newo/{customer}/actions.json`,
+ * and returns an object shaped for `createLinter({ schemas: { kind: 'inline', ... }})`.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { customerStateDir } from '../fsutil.js';
+import { getValidAccessToken } from '../auth.js';
+import { makeClient, getScriptActions } from '../api.js';
+export async function liveSchemaCachePath(customerIdn) {
+    const dir = customerStateDir(customerIdn);
+    await fs.ensureDir(dir);
+    return path.join(dir, 'actions.json');
+}
+/**
+ * Fetch the current action catalog from NEWO and cache it.
+ * Returns a snapshot ready to pass to `createLinter`.
+ */
+export async function refreshLiveSchema(customer) {
+    const token = await getValidAccessToken(customer);
+    const client = await makeClient(false, token);
+    const actions = await getScriptActions(client);
+    const snapshot = {
+        actions: actions.map((a) => ({
+            name: a.idn ?? a.title,
+            title: a.title,
+            ...(a.idn !== undefined ? { idn: a.idn } : {}),
+            arguments: a.arguments,
+        })),
+        fetchedAt: new Date().toISOString(),
+    };
+    const cachePath = await liveSchemaCachePath(customer.idn);
+    await fs.writeJson(cachePath, snapshot, { spaces: 2 });
+    return snapshot;
+}
+/**
+ * Load the cached snapshot if present. Returns null when the cache is
+ * missing or corrupt (caller should fall back to bundled schemas).
+ */
+export async function loadCachedLiveSchema(customerIdn) {
+    const cachePath = await liveSchemaCachePath(customerIdn);
+    if (!(await fs.pathExists(cachePath)))
+        return null;
+    try {
+        return (await fs.readJson(cachePath));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=live-schema.js.map

package/dist/lint/reporters/index.d.ts

@@ -0,0 +1,4 @@
+import type { Reporter, ReporterName } from './types.js';
+export type { Reporter, ReporterName } from './types.js';
+export declare function pickReporter(name: ReporterName | string | undefined): Reporter;
+//# sourceMappingURL=index.d.ts.map

package/dist/lint/reporters/index.js

@@ -0,0 +1,19 @@
+import { textReporter } from './text.js';
+import { jsonReporter } from './json.js';
+import { sarifReporter } from './sarif.js';
+export function pickReporter(name) {
+    switch (name) {
+        case 'json':
+            return jsonReporter;
+        case 'sarif':
+            return sarifReporter;
+        case 'text':
+        case undefined:
+        case '':
+            return textReporter;
+        default:
+            console.warn(`Unknown --format value '${name}', defaulting to text.`);
+            return textReporter;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/lint/reporters/json.d.ts

@@ -0,0 +1,3 @@
+import type { Reporter } from './types.js';
+export declare const jsonReporter: Reporter;
+//# sourceMappingURL=json.d.ts.map

package/dist/lint/reporters/json.js

@@ -0,0 +1,6 @@
+export const jsonReporter = {
+    write(report) {
+        return JSON.stringify(report, null, 2);
+    },
+};
+//# sourceMappingURL=json.js.map

package/dist/lint/reporters/sarif.d.ts

@@ -0,0 +1,3 @@
+import type { Reporter } from './types.js';
+export declare const sarifReporter: Reporter;
+//# sourceMappingURL=sarif.d.ts.map

package/dist/lint/reporters/sarif.js

@@ -0,0 +1,47 @@
+export const sarifReporter = {
+    write(report) {
+        const sarif = {
+            $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+            version: '2.1.0',
+            runs: [
+                {
+                    tool: {
+                        driver: {
+                            name: 'newo-lint',
+                            informationUri: 'https://github.com/sabbah13/newo-cli',
+                            rules: [],
+                        },
+                    },
+                    results: report.results.flatMap(r => r.diagnostics.map(d => buildResult(r.filePath, d))),
+                },
+            ],
+        };
+        return JSON.stringify(sarif, null, 2);
+    },
+};
+function buildResult(filePath, d) {
+    return {
+        ruleId: d.code,
+        level: d.severity === 'error' ? 'error' : d.severity === 'warning' ? 'warning' : 'note',
+        message: { text: d.message },
+        locations: [
+            {
+                physicalLocation: {
+                    artifactLocation: { uri: toUri(filePath) },
+                    region: {
+                        startLine: d.range.start.line,
+                        startColumn: d.range.start.column,
+                        endLine: d.range.end.line,
+                        endColumn: d.range.end.column,
+                    },
+                },
+            },
+        ],
+    };
+}
+function toUri(absPath) {
+    // SARIF artifact URIs should be workspace-relative when possible.
+    const rel = absPath.replace(process.cwd() + '/', '');
+    return rel.replace(/\\/g, '/');
+}
+//# sourceMappingURL=sarif.js.map

package/dist/lint/reporters/text.d.ts

@@ -0,0 +1,3 @@
+import type { Reporter } from './types.js';
+export declare const textReporter: Reporter;
+//# sourceMappingURL=text.d.ts.map

package/dist/lint/reporters/text.js

@@ -0,0 +1,51 @@
+/**
+ * Human-readable terminal reporter. Mirrors the ESLint 'stylish' layout:
+ *
+ *   path/to/file.jinja
+ *     12:5   error   Unknown skill: foo. Did you mean: bar?  E100
+ *     ...
+ *
+ *   2 problems (1 error, 1 warning)
+ */
+import path from 'path';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const GREY = '\x1b[90m';
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+export const textReporter = {
+    write(report) {
+        const lines = [];
+        const filesWithIssues = report.results.filter(r => r.diagnostics.length > 0);
+        for (const result of filesWithIssues) {
+            lines.push(renderFile(result));
+            lines.push('');
+        }
+        lines.push(renderSummary(report));
+        return lines.join('\n');
+    },
+};
+function renderFile(result) {
+    const rel = path.relative(process.cwd(), result.filePath);
+    const header = `${BOLD}${CYAN}${rel}${RESET}`;
+    const rows = result.diagnostics.map(d => {
+        const loc = `${d.range.start.line}:${d.range.start.column}`;
+        const sev = d.severity === 'error'
+            ? `${RED}error${RESET}`
+            : d.severity === 'warning'
+                ? `${YELLOW}warning${RESET}`
+                : `${GREY}${d.severity}${RESET}`;
+        return `  ${loc.padEnd(7)} ${sev.padEnd(16)} ${d.message}  ${GREY}${d.code}${RESET}`;
+    });
+    return [header, ...rows].join('\n');
+}
+function renderSummary(report) {
+    const total = report.errorCount + report.warningCount;
+    if (total === 0) {
+        return `${GREY}No issues found.${RESET}`;
+    }
+    const color = report.errorCount > 0 ? RED : YELLOW;
+    return `${color}${BOLD}${total} problems${RESET} (${report.errorCount} error${report.errorCount === 1 ? '' : 's'}, ${report.warningCount} warning${report.warningCount === 1 ? '' : 's'})`;
+}
+//# sourceMappingURL=text.js.map

package/dist/lint/reporters/types.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectLintReport } from 'newo-dsl-analyzer';
+export type ReporterName = 'text' | 'json' | 'sarif';
+export interface Reporter {
+    write(report: ProjectLintReport): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lint/reporters/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/sync/attributes.js

@@ -7,6 +7,7 @@ import path from 'path';
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
 import { patchYamlToPyyaml } from '../format/yaml-patch.js';
+import { isJsonValueType, normalizeJsonValueForStorage, jsonValuesEqual } from './json-attr-utils.js';
 /**
  * Save customer attributes to YAML format and return content for hashing
  */
@@ -28,16 +29,23 @@ export async function saveCustomerAttributes(client, customer, verbose = false)
             if (attr.id) {
                 idMapping[attr.idn] = attr.id;
             }
-            // Special handling for complex JSON string values
+            // Coerce JSON-typed values to a STRING. The API can return the value
+            // as a parsed object for `value_type: json` attributes; if we let
+            // yaml.dump serialize that as a YAML structure the next push sends
+            // `{"value": {...}}` instead of `{"value": "..."}` and the Workflow
+            // Builder canvas breaks. See src/sync/json-attr-utils.ts for the
+            // full rationale.
             let processedValue = attr.value;
-            if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+            if (isJsonValueType(attr.value_type)) {
+                processedValue = normalizeJsonValueForStorage(attr.value);
+            }
+            else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+                // Legacy: reformat array-of-objects JSON strings for readability
                 try {
-                    // Parse and reformat JSON for better readability
                     const parsed = JSON.parse(attr.value);
-                    processedValue = JSON.stringify(parsed, null, 0); // No extra spacing, but valid JSON
+                    processedValue = JSON.stringify(parsed, null, 0); // compact, valid JSON
                 }
                 catch (e) {
-                    // Keep original if parsing fails
                     processedValue = attr.value;
                 }
             }
@@ -114,9 +122,13 @@ export async function saveProjectAttributes(client, customer, projectId, project
             if (attr.id) {
                 idMapping[attr.idn] = attr.id;
             }
-            // Special handling for complex JSON string values
+            // Coerce JSON-typed values to a STRING. See json-attr-utils.ts for
+            // why this matters (Workflow Builder canvas blank-screen bug).
             let processedValue = attr.value;
-            if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+            if (isJsonValueType(attr.value_type)) {
+                processedValue = normalizeJsonValueForStorage(attr.value);
+            }
+            else if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
                 try {
                     const parsed = JSON.parse(attr.value);
                     processedValue = JSON.stringify(parsed, null, 0);
@@ -243,17 +255,31 @@ export async function pushProjectAttributes(client, customer, projectId, project
         }
         // Value type is already parsed (we removed !enum tags above)
         const valueType = localAttr.value_type;
-        // Check if value changed (use ?? to preserve 0, false, empty string)
-        const localValue = String(localAttr.value ?? '');
-        const remoteValue = String(remoteAttr.value ?? '');
-        if (localValue !== remoteValue) {
+        const isJson = isJsonValueType(valueType);
+        // Check if value changed.
+        // For JSON-typed values, compare canonical (compact) JSON so that
+        // pretty- vs compact-printed forms don't register as changes and
+        // string vs object representations compare equal. For everything
+        // else, fall back to the existing String() comparison (which still
+        // preserves 0, false, "" via ??).
+        const valuesAreEqual = isJson
+            ? jsonValuesEqual(localAttr.value, remoteAttr.value)
+            : String(localAttr.value ?? '') === String(remoteAttr.value ?? '');
+        if (!valuesAreEqual) {
             if (verbose)
                 console.log(`   🔄 Updating project attribute: ${localAttr.idn}`);
             try {
+                // Always send JSON-typed values as a STRING. If the API or our
+                // YAML loader handed us an object, the platform stores it
+                // differently from the original string and the Workflow Builder
+                // canvas blanks out.
+                const valueToSend = isJson
+                    ? normalizeJsonValueForStorage(localAttr.value)
+                    : localAttr.value;
                 const attributeToUpdate = {
                     id: attributeId,
                     idn: localAttr.idn,
-                    value: localAttr.value,
+                    value: valueToSend,
                     title: localAttr.title,
                     description: localAttr.description,
                     group: localAttr.group,

package/dist/sync/conversations.d.ts

@@ -1,7 +1,7 @@
 import type { AxiosInstance } from 'axios';
 import type { CustomerConfig, ConversationOptions } from '../types.js';
 /**
- * Pull conversations for a customer and save to YAML
+ * Pull conversations for a customer and save incrementally.
  */
 export declare function pullConversations(client: AxiosInstance, customer: CustomerConfig, options?: ConversationOptions, verbose?: boolean): Promise<void>;
 //# sourceMappingURL=conversations.d.ts.map