newo 3.6.1 → 3.7.0

package/CHANGELOG.md

@@ -7,6 +7,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.7.0] - 2026-04-23
+
+### Added
+
+- **`newo lint` command** - Static analysis for Guidance / Jinja / NSL / NSLG files. Exit codes 0/1/2. Flags: `--format`, `--reporter text|json|sarif`, `--max-warnings`, `--quiet`, `--rule`, `--rule-off`, `--changed`, `--live`, `--customer`. Powered by `newo-dsl-analyzer`, the same engine used by the VS Code extension.
+- **`newo format` command** - Apply canonical formatting in place. `--check` flag reports without writing (CI gate). v1 is an identity transform that ensures final newline; concrete formatting rules iterate in later releases.
+- **`newo check` command** - Umbrella command: runs `lint` then `format --check` for a single CI gate invocation.
+- **`src/lint/` glue module** - File discovery respecting format-aware extensions and `.newo/{customer}/hashes.json` for `--changed`, `.neworc.yaml` config loader, live schema refresh (caches `/api/v1/script/actions` response to `.newo/{customer}/actions.json`), text/JSON/SARIF 2.1.0 reporters.
+- **Dependency on `newo-dsl-analyzer` and `newo-dsl-core`** - the shared Newo DSL analysis engine published from the newo-nsl-lsp repo. See README for the plugin contract.
+- **Offline mode for lint/format/check** - These commands do not require `NEWO_API_KEY` or any environment configuration when run with explicit paths and without `--customer` or `--live`. Safe for pre-commit hooks and sandboxed CI jobs.
+- **`.neworc.yaml` config discovery** - Walks up the directory tree from cwd to find lint config. Supports `rules`, `plugins`, `extensions`, `ignore`.
+
+### Changed
+
+- `src/cli.ts` short-circuits environment validation for offline `newo lint` / `newo format` / `newo check` invocations. All other commands still require credentials at startup.
+
+### Publisher notes
+
+Before running `npm publish` on this version, swap the local `file:` dependencies in `package.json` for semver ranges (npm rejects published packages that reference `file:` paths). The `newo-dsl-*` packages must be published from the [newo-nsl-lsp](https://github.com/newo-ai/newo-nsl-lsp) monorepo first:
+
+```json
+"dependencies": {
+  "newo-dsl-analyzer": "^1.0.0",
+  "newo-dsl-core": "^1.0.0",
+  ...
+}
+```
+
+Recommended release order:
+1. Tag `v1.0.0` on newo-nsl-lsp -> CI publishes `newo-dsl-core`, `newo-dsl-data`, `newo-dsl-analyzer`, `newo-dsl-lsp` to npm.
+2. In newo-cli: swap `file:` to `^1.0.0`, `npm install`, build, test.
+3. Tag `v3.7.0` on newo-cli -> `npm publish --access public`.
+
+## [3.6.2] - 2026-04-23
+
+### Fixed
+
+- **`attributes.yaml` YAML escaping** - Values containing double quotes (e.g. `["+37410333310"]`) are now serialized as single-quoted scalars instead of invalid double-quoted output. Previously `newo push --format newo_v2` could not parse round-tripped files because the generated YAML was malformed. Fix ported via PR #1 (commit `d3a1d4e`).
+
 ## [3.6.1] - 2026-04-14
 
 ### Documentation
@@ -999,6 +1038,8 @@ Another Item: $Price [Modifiers: modifier3]
 [3.2.0]: https://github.com/sabbah13/newo-cli/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/sabbah13/newo-cli/compare/v3.0.0...v3.1.0
 [3.0.0]: https://github.com/sabbah13/newo-cli/compare/v2.0.6...v3.0.0
+[3.7.0]: https://github.com/sabbah13/newo-cli/compare/v3.6.2...v3.7.0
+[3.6.2]: https://github.com/sabbah13/newo-cli/compare/v3.6.1...v3.6.2
 [2.0.6]: https://github.com/sabbah13/newo-cli/compare/v2.0.5...v2.0.6
 [2.0.5]: https://github.com/sabbah13/newo-cli/compare/v2.0.4...v2.0.5
 [2.0.4]: https://github.com/sabbah13/newo-cli/compare/v2.0.3...v2.0.4

package/README.md

@@ -153,6 +153,67 @@ NEWO_REFRESH_URL=custom_refresh_endpoint   # Custom refresh endpoint
 | `newo import-akb` | Import knowledge base articles | • Structured text parsing<br>• Bulk article import<br>• Validation and error reporting |
 | `newo meta` | Get project metadata (debug) | • Project structure analysis<br>• Metadata validation |
 
+### Lint, Format, Check (NEW v3.7.0)
+
+Static-analysis over DSL files, powered by [`newo-dsl-analyzer`](https://www.npmjs.com/package/newo-dsl-analyzer). Same engine that runs in the VS Code extension - no drift between editor and CI.
+
+| Command | Description |
+|---------|-------------|
+| `newo lint [paths...]` | Lint Guidance / Jinja / NSL / NSLG files. Exit 0 clean, 1 findings, 2 runtime error. |
+| `newo format [paths...]` | Apply canonical formatting in place. Use `--check` to only report (no writes). |
+| `newo check [paths...]` | Umbrella: runs `lint` then `format --check`. Single CI gate. |
+
+**Lint flags:**
+
+| Flag | Purpose |
+|------|---------|
+| `--format <cli_v1\|newo_v2>` | Restrict file extensions to one format's set |
+| `--reporter <text\|json\|sarif>` | Output format. `sarif` is ready for GitHub Code Scanning |
+| `--max-warnings <n>` | Exit 1 if warning count exceeds threshold |
+| `--quiet` | Errors only (filters warnings from output) |
+| `--rule <code>` / `--rule-off <code>` | Enable / disable specific rules (comma-separated or repeatable) |
+| `--changed` | Lint only files modified since last `newo push` (uses `.newo/{customer}/hashes.json`) |
+| `--live` | Refresh schemas from NEWO API (`/api/v1/script/actions`) and cache to `.newo/{customer}/actions.json` |
+| `--customer <idn>` | Scope to one configured customer |
+
+**Config file:** `.neworc.yaml` at your repo root (or any ancestor directory):
+
+```yaml
+rules:
+  E100: error      # Unknown skill
+  W101: off        # Unknown function (useful when using bundled schemas without --live)
+  W102: warning    # Unknown parameter
+ignore:
+  - archived/
+plugins:
+  - ./my-lint-plugin
+```
+
+**Examples:**
+
+```bash
+# Quick lint of the current directory
+newo lint newo_customers
+
+# Lint only changed files, as SARIF, suitable for GitHub PR comments
+newo lint --changed --reporter sarif > lint.sarif
+
+# Lint one customer with platform-fresh schemas
+newo lint --customer acme --live
+
+# CI gate
+newo check --max-warnings 0
+
+# Pre-commit: auto-format then lint
+newo format && newo lint
+```
+
+**Exit codes:** 0 clean / 1 findings (errors present OR `--max-warnings` exceeded) / 2 runtime error.
+
+**Offline mode:** `newo lint`, `newo format`, and `newo check` do not require `NEWO_API_KEY` or any environment configuration when run with explicit paths and without `--customer` / `--live`. Safe to use in sandboxes and pre-commit hooks.
+
+**Plugin authors:** depend on [`newo-dsl-core`](https://www.npmjs.com/package/newo-dsl-core) and register your plugin in `.neworc.yaml`. See the analyzer README for the full rule API.
+
 ### V2 Format Support (NEW v3.6.0)
 
 The CLI supports two formats that coexist in the same workspace:

package/dist/cli/commands/check.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleCheckCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose: boolean): Promise<void>;
+//# sourceMappingURL=check.d.ts.map

package/dist/cli/commands/check.js

@@ -0,0 +1,15 @@
+/**
+ * `newo check` - umbrella command equivalent to running lint + format --check.
+ *
+ * A failing check exits non-zero if any of the sub-checks fail, so CI
+ * pipelines can gate merges on a single invocation.
+ */
+import { handleLintCommand } from './lint.js';
+import { handleFormatCommand } from './format.js';
+export async function handleCheckCommand(customerConfig, args, verbose) {
+    const lintArgs = { ...args };
+    await handleLintCommand(customerConfig, lintArgs, verbose);
+    const formatCheckArgs = { ...args, check: true };
+    await handleFormatCommand(customerConfig, formatCheckArgs, verbose);
+}
+//# sourceMappingURL=check.js.map

package/dist/cli/commands/format.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleFormatCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose: boolean): Promise<void>;
+//# sourceMappingURL=format.d.ts.map

package/dist/cli/commands/format.js

@@ -0,0 +1,105 @@
+/**
+ * `newo format` - apply canonical formatting to DSL files.
+ *
+ * Invokes newo-dsl-analyzer's Formatter. In v1 the formatter is an
+ * identity transform (just ensures a final newline). Concrete rules
+ * land in subsequent versions; the command surface is stable now so
+ * CI pipelines and pre-commit hooks can wire `newo format --check`
+ * immediately.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { createFormatter } from 'newo-dsl-analyzer';
+import { selectSingleCustomer } from '../customer-selection.js';
+import { handleCliError } from '../errors.js';
+import { resolveFormat } from '../../format/detect.js';
+import { discoverCustomerFiles, discoverFromPath, defaultRoot } from '../../lint/discovery.js';
+export async function handleFormatCommand(customerConfig, args, verbose) {
+    try {
+        const fmtArgs = parseArgs(args);
+        const formatter = createFormatter();
+        const hasCustomerContext = fmtArgs.customer !== undefined ||
+            Object.keys(customerConfig.customers ?? {}).length > 0;
+        const { selectedCustomer, allCustomers, isMultiCustomer } = hasCustomerContext
+            ? selectSingleCustomer(customerConfig, fmtArgs.customer)
+            : { selectedCustomer: null, allCustomers: [], isMultiCustomer: false };
+        const targetCustomer = selectedCustomer ?? (isMultiCustomer ? null : allCustomers[0] ?? null);
+        void targetCustomer;
+        const files = await resolveFiles(targetCustomer, allCustomers, fmtArgs, isMultiCustomer);
+        if (files.length === 0) {
+            console.log('No files matched.');
+            return;
+        }
+        let touched = 0;
+        let needsFormat = 0;
+        for (const file of files) {
+            const source = await fs.readFile(file.absPath, 'utf8');
+            const result = formatter.format(source, file.absPath);
+            if (!result.changed)
+                continue;
+            needsFormat++;
+            if (fmtArgs.check) {
+                console.log(`would rewrite ${path.relative(process.cwd(), file.absPath)}`);
+            }
+            else {
+                await fs.writeFile(file.absPath, result.formatted, 'utf8');
+                touched++;
+                if (verbose)
+                    console.log(`formatted ${path.relative(process.cwd(), file.absPath)}`);
+            }
+        }
+        if (fmtArgs.check) {
+            if (needsFormat === 0) {
+                console.log('All files are properly formatted.');
+                return;
+            }
+            console.log(`${needsFormat} file(s) would be reformatted.`);
+            process.exit(1);
+        }
+        else {
+            console.log(`Formatted ${touched} file(s).`);
+        }
+    }
+    catch (err) {
+        handleCliError(err, 'format');
+    }
+}
+function parseArgs(args) {
+    const positional = args._.slice(1).filter((p) => typeof p === 'string');
+    return {
+        positional,
+        formatVersion: args.format,
+        check: Boolean(args.check),
+        customer: args.customer,
+    };
+}
+async function resolveFiles(selected, all, args, isMultiCustomer) {
+    if (args.positional.length > 0) {
+        const files = [];
+        for (const p of args.positional) {
+            files.push(...(await discoverFromPath(p, {
+                ...(args.formatVersion ? { format: toFormatVersion(args.formatVersion) } : {}),
+            })));
+        }
+        return files;
+    }
+    if (selected) {
+        const formatVersion = resolveFormat(selected.idn, args.formatVersion).version;
+        return discoverCustomerFiles(selected, { format: formatVersion });
+    }
+    if (isMultiCustomer) {
+        const files = [];
+        for (const customer of all) {
+            const formatVersion = resolveFormat(customer.idn, args.formatVersion).version;
+            files.push(...(await discoverCustomerFiles(customer, { format: formatVersion })));
+        }
+        return files;
+    }
+    return discoverFromPath(defaultRoot(), {
+        ...(args.formatVersion ? { format: toFormatVersion(args.formatVersion) } : {}),
+    });
+}
+function toFormatVersion(v) {
+    return v === 'newo_v2' ? 'newo_v2' : 'cli_v1';
+}
+//# sourceMappingURL=format.js.map

package/dist/cli/commands/help.js

@@ -21,6 +21,19 @@ Core Commands:
   newo meta [--customer <idn>]                  # get project metadata (debug)
   newo import-akb <file> <persona_id> [--customer <idn>]  # import AKB articles
 
+Linting & Formatting (NEW):
+  newo lint [paths...] [--format <fmt>] [--reporter <text|json|sarif>]       # static-analysis on DSL files
+  newo lint --changed                                                        # lint only files modified since last push
+  newo lint --live                                                           # refresh action catalog from NEWO API
+  newo lint --rule <code> --no-rule <code>                                   # selectively enable/disable rules
+  newo lint --max-warnings <n>                                               # fail when warnings exceed threshold
+  newo format [paths...] [--check]                                           # apply canonical formatting (in-place or --check)
+  newo check [paths...]                                                      # umbrella: lint + format --check (CI gate)
+
+  Powered by newo-dsl-analyzer. Exit codes: 0 clean, 1 lint errors, 2 runtime error.
+  Discover rules via the Diagnostic code column (E100, W101, ...); configure
+  them in .neworc.yaml at your repo root. Plugin authors: depend on newo-dsl-core.
+
 Project Management:
   newo create-project <idn> [--title <title>] [--description <desc>] [--version <version>] [--auto-update]  # create empty project on platform
   newo list-registries [--customer <idn>]                                   # list available project registries (production, staging, etc.)

package/dist/cli/commands/lint.d.ts

@@ -0,0 +1,3 @@
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+export declare function handleLintCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose: boolean): Promise<void>;
+//# sourceMappingURL=lint.d.ts.map

package/dist/cli/commands/lint.js

@@ -0,0 +1,195 @@
+/**
+ * `newo lint` - static analysis over Guidance / Jinja / NSL / NSLG files.
+ *
+ * Wraps newo-dsl-analyzer with newo-cli's customer/format/hash primitives.
+ * Exit codes:
+ *   0  clean (or only warnings below --max-warnings)
+ *   1  lint errors found, or warning threshold exceeded
+ *   2  unexpected runtime failure (handled by handleCliError)
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { createLinter, } from 'newo-dsl-analyzer';
+import { selectSingleCustomer } from '../customer-selection.js';
+import { handleCliError } from '../errors.js';
+import { resolveFormat } from '../../format/detect.js';
+import { discoverCustomerFiles, discoverFromPath, defaultRoot } from '../../lint/discovery.js';
+import { loadNewoLintConfig } from '../../lint/config.js';
+import { refreshLiveSchema, loadCachedLiveSchema } from '../../lint/live-schema.js';
+import { pickReporter } from '../../lint/reporters/index.js';
+export async function handleLintCommand(customerConfig, args, verbose) {
+    try {
+        const lintArgs = parseArgs(args);
+        const report = await run(customerConfig, lintArgs, verbose);
+        const reporter = pickReporter(lintArgs.reporter);
+        const output = reporter.write(report);
+        if (output.trim().length > 0)
+            process.stdout.write(output + '\n');
+        const exitCode = determineExitCode(report, lintArgs);
+        if (exitCode !== 0)
+            process.exit(exitCode);
+    }
+    catch (err) {
+        handleCliError(err, 'lint');
+    }
+}
+function parseArgs(args) {
+    const positional = args._.slice(1).filter((p) => typeof p === 'string');
+    // Multiple flag shapes: --rule=E100, --rule E100,W100
+    // Disabling rules uses --rule-off (not --no-rule) because minimist treats
+    // `--no-X` as `X: false` and swallows the next positional argument.
+    const rules = collectCsv(args.rule);
+    const noRules = collectCsv(args['rule-off']);
+    return {
+        positional,
+        formatVersion: args.format,
+        reporter: args.reporter ?? args['output-format'] ?? 'text',
+        maxWarnings: parseIntOr(args['max-warnings'], Number.POSITIVE_INFINITY),
+        quiet: Boolean(args.quiet),
+        rules,
+        noRules,
+        changed: Boolean(args.changed),
+        live: Boolean(args.live),
+        customer: args.customer,
+    };
+}
+async function run(customerConfig, args, verbose) {
+    const config = loadNewoLintConfig();
+    // With explicit positional paths AND no customer/live flag, skip customer
+    // selection entirely - lint operates purely on the given filesystem paths.
+    const hasCustomerContext = args.customer !== undefined ||
+        args.live ||
+        Object.keys(customerConfig.customers ?? {}).length > 0;
+    const { selectedCustomer, allCustomers, isMultiCustomer } = hasCustomerContext
+        ? selectSingleCustomer(customerConfig, args.customer)
+        : { selectedCustomer: null, allCustomers: [], isMultiCustomer: false };
+    const targetCustomer = selectedCustomer ?? (isMultiCustomer ? null : allCustomers[0] ?? null);
+    const schemas = await resolveSchemas(targetCustomer, args, verbose);
+    const ruleOverrides = {
+        ...(config.rules ?? {}),
+    };
+    for (const code of args.noRules)
+        ruleOverrides[code] = 'off';
+    // --rule enables; we map unknown codes to 'warning' to avoid silently accepting typos.
+    for (const code of args.rules) {
+        if (!(code in ruleOverrides) || ruleOverrides[code] === 'off') {
+            ruleOverrides[code] = 'warning';
+        }
+    }
+    const linterOpts = {
+        rules: ruleOverrides,
+        ...(schemas !== undefined ? { schemas } : {}),
+    };
+    const linter = createLinter(linterOpts);
+    const files = await resolveFiles(targetCustomer, allCustomers, args, isMultiCustomer);
+    if (files.length === 0) {
+        return { results: [], errorCount: 0, warningCount: 0 };
+    }
+    let errorCount = 0;
+    let warningCount = 0;
+    const results = [];
+    for (const file of files) {
+        const source = await fs.readFile(file.absPath, 'utf8');
+        const result = linter.lint(source, file.absPath);
+        for (const d of result.diagnostics) {
+            if (d.severity === 'error')
+                errorCount++;
+            else if (d.severity === 'warning')
+                warningCount++;
+        }
+        if (args.quiet) {
+            result.diagnostics = result.diagnostics.filter(d => d.severity === 'error');
+        }
+        results.push(result);
+    }
+    return { results, errorCount, warningCount: args.quiet ? 0 : warningCount };
+}
+async function resolveSchemas(customer, args, verbose) {
+    if (!customer)
+        return 'bundled';
+    if (args.live) {
+        if (verbose)
+            console.log(`Refreshing live schemas for ${customer.idn}...`);
+        const snapshot = await refreshLiveSchema(customer);
+        return { kind: 'inline', actions: snapshot.actions };
+    }
+    // Auto-use cached live snapshot if it exists (faster, always specific to
+    // the customer's actual NEWO account state). Fall back to bundled.
+    const cached = await loadCachedLiveSchema(customer.idn);
+    if (cached) {
+        if (verbose) {
+            const age = Math.round((Date.now() - Date.parse(cached.fetchedAt)) / 1000 / 60);
+            console.log(`Using cached schemas for ${customer.idn} (${age} min old). Use --live to refresh.`);
+        }
+        return { kind: 'inline', actions: cached.actions };
+    }
+    return 'bundled';
+}
+async function resolveFiles(selected, all, args, isMultiCustomer) {
+    // Explicit positional paths beat everything else.
+    if (args.positional.length > 0) {
+        const files = [];
+        for (const p of args.positional) {
+            const discovered = await discoverFromPath(p, {
+                ...(args.formatVersion ? { format: toFormatVersion(args.formatVersion) } : {}),
+            });
+            files.push(...discovered);
+        }
+        return files;
+    }
+    if (selected) {
+        const formatVersion = resolveFormat(selected.idn, args.formatVersion).version;
+        return discoverCustomerFiles(selected, {
+            format: formatVersion,
+            changedOnly: args.changed,
+        });
+    }
+    if (isMultiCustomer) {
+        const files = [];
+        for (const customer of all) {
+            const formatVersion = resolveFormat(customer.idn, args.formatVersion).version;
+            const customerFiles = await discoverCustomerFiles(customer, {
+                format: formatVersion,
+                changedOnly: args.changed,
+            });
+            files.push(...customerFiles);
+        }
+        return files;
+    }
+    // No customer context - lint cwd / newo_customers/ directly.
+    return discoverFromPath(defaultRoot(), {
+        ...(args.formatVersion ? { format: toFormatVersion(args.formatVersion) } : {}),
+    });
+}
+function determineExitCode(report, args) {
+    if (report.errorCount > 0)
+        return 1;
+    if (report.warningCount > args.maxWarnings)
+        return 1;
+    return 0;
+}
+function collectCsv(value) {
+    if (value === undefined || value === null)
+        return [];
+    const items = Array.isArray(value) ? value : [value];
+    return items
+        .flatMap((v) => String(v).split(','))
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+}
+function parseIntOr(value, fallback) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string') {
+        const parsed = Number.parseInt(value, 10);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return fallback;
+}
+function toFormatVersion(v) {
+    return v === 'newo_v2' ? 'newo_v2' : 'cli_v1';
+}
+// Silence unused path import warning; path is used via discovery helpers.
+void path;
+//# sourceMappingURL=lint.js.map

package/dist/cli-new/di/tokens.d.ts

@@ -62,7 +62,7 @@ export declare const RESOURCE_TYPES: {
 /**
  * All available resource types for sync operations
  */
-export declare const ALL_RESOURCE_TYPES: ("projects" | "integrations" | "akb" | "attributes" | "conversations")[];
+export declare const ALL_RESOURCE_TYPES: ("projects" | "conversations" | "integrations" | "akb" | "attributes")[];
 /**
  * Pushable resource types (excludes read-only resources like conversations)
  */

package/dist/cli.js

@@ -47,16 +47,11 @@ import { handleWatchCommand } from './cli/commands/watch.js';
 import { handleDiffCommand } from './cli/commands/diff.js';
 import { handleLogsCommand } from './cli/commands/logs.js';
 import { handleExportCommand } from './cli/commands/export.js';
+import { handleLintCommand } from './cli/commands/lint.js';
+import { handleFormatCommand } from './cli/commands/format.js';
+import { handleCheckCommand } from './cli/commands/check.js';
 dotenv.config();
 async function main() {
-    try {
-        // Initialize and validate environment at startup
-        initializeEnvironment();
-    }
-    catch (error) {
-        console.error('Environment validation failed:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
     const args = minimist(process.argv.slice(2));
     const cmd = args._[0];
     const verbose = Boolean(args.verbose || args.v);
@@ -67,11 +62,43 @@ async function main() {
     }
     if (verbose)
         console.log(`🔍 Command parsed: "${cmd}"`);
-    // Handle help command first
+    // Handle help command first - no env or customer config needed
     if (!cmd || ['help', '-h', '--help'].includes(cmd)) {
         handleHelpCommand();
         return;
     }
+    // Offline commands: lint/format/check don't need NEWO credentials
+    // UNLESS the user passes --customer or --live (both touch the API).
+    const isOfflineLint = (cmd === 'lint' || cmd === 'format' || cmd === 'check') &&
+        !args.customer &&
+        !args.live;
+    if (isOfflineLint) {
+        try {
+            const emptyConfig = { customers: {} };
+            switch (cmd) {
+                case 'lint':
+                    await handleLintCommand(emptyConfig, args, verbose);
+                    return;
+                case 'format':
+                    await handleFormatCommand(emptyConfig, args, verbose);
+                    return;
+                case 'check':
+                    await handleCheckCommand(emptyConfig, args, verbose);
+                    return;
+            }
+        }
+        catch (error) {
+            handleCliError(error, cmd);
+        }
+    }
+    // All other commands (and customer-scoped lint/format/check) require env + customer config.
+    try {
+        initializeEnvironment();
+    }
+    catch (error) {
+        console.error('Environment validation failed:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
     // Handle list-customers command (doesn't need full customer config)
     if (cmd === 'list-customers') {
         try {
@@ -204,6 +231,15 @@ async function main() {
             case 'diff':
                 await handleDiffCommand(customerConfig, args, verbose);
                 break;
+            case 'lint':
+                await handleLintCommand(customerConfig, args, verbose);
+                break;
+            case 'format':
+                await handleFormatCommand(customerConfig, args, verbose);
+                break;
+            case 'check':
+                await handleCheckCommand(customerConfig, args, verbose);
+                break;
             default:
                 console.error('Unknown command:', cmd);
                 console.error('Run "newo --help" for usage information');

package/dist/domain/strategies/sync/AttributeSyncStrategy.js

@@ -14,6 +14,7 @@ import yaml from 'js-yaml';
 import path from 'path';
 import { getCustomerAttributes, getProjectAttributes, updateCustomerAttribute, updateProjectAttribute, listProjects } from '../../../api.js';
 import { writeFileSafe, customerAttributesPath, customerAttributesMapPath } from '../../../fsutil.js';
+import { patchYamlToPyyaml } from '../../../format/yaml-patch.js';
 import { sha256, saveHashes, loadHashes } from '../../../hash.js';
 /**
  * AttributeSyncStrategy - Handles attribute synchronization
@@ -171,18 +172,20 @@ export class AttributeSyncStrategy {
             ...attr,
             value_type: `__ENUM_PLACEHOLDER_${attr.value_type}__`
         }));
+        // Emit YAML without folding/wrapping; patchYamlToPyyaml handles long-line
+        // wrapping and converts JSON-like double-quoted values to single-quoted
+        // (so strings containing `"` stay valid YAML on reload).
         let yamlContent = yaml.dump({ attributes: attributesWithPlaceholders }, {
             indent: 2,
             quotingType: '"',
             forceQuotes: false,
-            lineWidth: 80,
+            lineWidth: -1,
             noRefs: true,
             sortKeys: false,
-            flowLevel: -1
+            flowLevel: -1,
         });
-        // Replace placeholders with enum syntax
         yamlContent = yamlContent.replace(/__ENUM_PLACEHOLDER_(\w+)__/g, '!enum "AttributeValueTypes.$1"');
-        yamlContent = yamlContent.replace(/\\"/g, '"');
+        yamlContent = patchYamlToPyyaml(yamlContent);
         return yamlContent;
     }
     /**

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