newo 3.6.2 → 3.7.0

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/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