proteum 2.2.7 → 2.2.9

package/tests/agents-utils.test.cjs

@@ -159,12 +159,67 @@ test('monorepo configure writes root and app instruction files', () => {
     fs.mkdirSync(path.join(monorepoRoot, '.git'));
     fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
 
+    configureProjectAgentInstructions({ appRoot, coreRoot });
+
     const result = configureProjectAgentInstructions({ appRoot, coreRoot, monorepoRoot });
 
     assert.equal(result.mode, 'monorepo');
     assert.equal(resolveProjectAgentMonorepoRoot(appRoot), fs.realpathSync(monorepoRoot));
     assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /## Source: AGENTS\.md/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'CODING_STYLE.md'), 'utf8'), /## Source: CODING_STYLE\.md/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'diagnostics.md'), 'utf8'), /## Source: AGENTS\.md/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'optimizations.md'), 'utf8'), /## Source: AGENTS\.md/);
     assert.match(fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8'), /## Source: client\/AGENTS\.md/);
+    assert.equal(fs.existsSync(path.join(appRoot, 'CODING_STYLE.md')), false);
+    assert.equal(fs.existsSync(path.join(appRoot, 'diagnostics.md')), false);
+    assert.equal(fs.existsSync(path.join(appRoot, 'optimizations.md')), false);
+    assert.equal(result.removed.some((entry) => entry.endsWith('/apps/product/CODING_STYLE.md')), true);
+});
+
+test('monorepo configure preserves local app-root documents', () => {
+    const coreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const appRoot = path.join(monorepoRoot, 'apps', 'product');
+    const localCodingStylePath = path.join(appRoot, 'CODING_STYLE.md');
+
+    fs.mkdirSync(path.join(monorepoRoot, '.git'));
+    writeFile(localCodingStylePath, '# Local Coding Style\n\n- Keep this app-local override.\n');
+
+    const result = configureProjectAgentInstructions({ appRoot, coreRoot, monorepoRoot });
+
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'CODING_STYLE.md'), 'utf8'), /## Source: CODING_STYLE\.md/);
+    assert.match(fs.readFileSync(localCodingStylePath, 'utf8'), /Keep this app-local override/);
+    assert.equal(result.removed.some((entry) => entry.endsWith('/apps/product/CODING_STYLE.md')), false);
+});
+
+test('monorepo configure strips retired managed sections from local app-root documents', () => {
+    const coreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const appRoot = path.join(monorepoRoot, 'apps', 'product');
+    const localCodingStylePath = path.join(appRoot, 'CODING_STYLE.md');
+
+    fs.mkdirSync(path.join(monorepoRoot, '.git'));
+    fs.mkdirSync(appRoot, { recursive: true });
+    configureProjectAgentInstructions({ appRoot, coreRoot });
+
+    const managedContent = fs.readFileSync(localCodingStylePath, 'utf8');
+    writeFile(
+        localCodingStylePath,
+        [
+            '# Local Coding Style',
+            '',
+            '- Keep this app-local override.',
+            '',
+            managedContent,
+        ].join('\n'),
+    );
+
+    const result = configureProjectAgentInstructions({ appRoot, coreRoot, monorepoRoot });
+    const retainedContent = fs.readFileSync(localCodingStylePath, 'utf8');
+
+    assert.match(retainedContent, /Keep this app-local override/);
+    assert.doesNotMatch(retainedContent, /proteum-instructions:start/);
+    assert.equal(result.updated.some((entry) => entry.endsWith('/apps/product/CODING_STYLE.md')), true);
 });
 
 test('configure migrates legacy managed symlinks to embedded files', () => {

package/tests/eslint-rules.test.cjs

@@ -0,0 +1,110 @@
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const { Linter } = require('eslint');
+
+const { createProteumEslintConfig } = require('../eslint.js');
+
+const lint = (code) => {
+    const linter = new Linter({ configType: 'flat' });
+    return linter.verify(code, createProteumEslintConfig(), {
+        filename: 'client/example.tsx',
+    });
+};
+
+const swallowedErrorRuleId = 'proteum/no-swallowed-caught-error';
+
+test('proteum lint rejects empty catch blocks', () => {
+    const messages = lint(`
+        export const run = () => {
+            try {
+                risky();
+            } catch {
+                return null;
+            }
+        };
+    `);
+
+    assert.equal(messages.some((message) => message.ruleId === swallowedErrorRuleId), true);
+});
+
+test('proteum lint rejects promise catches that discard the error', () => {
+    const messages = lint(`
+        export const run = () => {
+            api.load().catch(() => toast.error('Could not load'));
+        };
+    `);
+
+    assert.equal(messages.some((message) => message.ruleId === swallowedErrorRuleId), true);
+});
+
+test('proteum lint rejects generic catch feedback that drops original error details', () => {
+    const messages = lint(`
+        export const run = async () => {
+            try {
+                await Investor.api.getDashboard();
+            } catch (error) {
+                toast.error('Could not load API dashboard');
+            }
+        };
+    `);
+
+    assert.equal(messages.some((message) => message.ruleId === swallowedErrorRuleId), true);
+});
+
+test('proteum lint allows rethrowing the caught error', () => {
+    const messages = lint(`
+        export const run = async () => {
+            try {
+                await Investor.api.getDashboard();
+            } catch (error) {
+                toast.error('Could not load API dashboard');
+                throw error;
+            }
+        };
+    `);
+
+    assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
+});
+
+test('proteum lint allows surfacing original error details', () => {
+    const messages = lint(`
+        export const run = async () => {
+            try {
+                await Investor.api.getDashboard();
+            } catch (error) {
+                toast.error('Could not load API dashboard', {
+                    description: error instanceof Error ? error.message : String(error),
+                });
+            }
+        };
+    `);
+
+    assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
+});
+
+test('proteum lint allows surfacing a message derived from the caught error', () => {
+    const messages = lint(`
+        export const run = async () => {
+            try {
+                await Investor.api.getDashboard();
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                setError(message);
+            }
+        };
+    `);
+
+    assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
+});
+
+test('proteum lint allows routing promise failures to app error handling', () => {
+    const messages = lint(`
+        export const run = () => {
+            Investor.api.ensureApiKey().catch((error) => {
+                Router.app.handleError(error);
+            });
+        };
+    `);
+
+    assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
+});

package/types/global/vendors.d.ts

@@ -68,6 +68,76 @@ declare module 'morgan' {
     export default morgan;
 }
 
+declare module 'object-hash' {
+    export type ObjectHashOptions = {
+        unorderedArrays?: boolean;
+        unorderedObjects?: boolean;
+    };
+    export type ObjectHashValue =
+        | string
+        | number
+        | boolean
+        | null
+        | undefined
+        | Date
+        | ObjectHashValue[]
+        | { [key: string]: ObjectHashValue };
+
+    const objectHash: (value: ObjectHashValue, options?: ObjectHashOptions) => string;
+    export default objectHash;
+}
+
+declare module 'fs-extra' {
+    type FsJsonValue =
+        | string
+        | number
+        | boolean
+        | null
+        | FsJsonValue[]
+        | { [key: string]: FsJsonValue };
+    type FsExtraModule = {
+        createReadStream: typeof import('fs').createReadStream;
+        ensureDirSync(path: import('fs').PathLike): void;
+        existsSync: typeof import('fs').existsSync;
+        moveSync(source: import('fs').PathLike, destination: import('fs').PathLike, options?: { overwrite?: boolean }): void;
+        outputFileSync(
+            file: import('fs').PathOrFileDescriptor,
+            data: string | NodeJS.ArrayBufferView,
+            options?: import('fs').WriteFileOptions | { encoding?: string },
+        ): void;
+        readdir: typeof import('fs/promises').readdir;
+        readdirSync: typeof import('fs').readdirSync;
+        readFile: typeof import('fs/promises').readFile;
+        readFileSync: typeof import('fs').readFileSync;
+        readJSONSync<TValue = FsJsonValue>(path: import('fs').PathLike): TValue;
+        readJsonSync<TValue = FsJsonValue>(path: import('fs').PathLike): TValue;
+        removeSync(path: import('fs').PathLike): void;
+        statSync: typeof import('fs').statSync;
+        writeJSONSync(path: import('fs').PathLike, data: FsJsonValue | object, options?: Record<string, unknown>): void;
+    };
+
+    const fsExtra: FsExtraModule;
+    export default fsExtra;
+    export const createReadStream: FsExtraModule['createReadStream'];
+    export const ensureDirSync: FsExtraModule['ensureDirSync'];
+    export const existsSync: FsExtraModule['existsSync'];
+    export const moveSync: FsExtraModule['moveSync'];
+    export const outputFileSync: FsExtraModule['outputFileSync'];
+    export const readdir: typeof import('fs/promises').readdir;
+    export const readdirSync: FsExtraModule['readdirSync'];
+    export const readFile: typeof import('fs/promises').readFile;
+    export const readFileSync: FsExtraModule['readFileSync'];
+    export const readJSONSync: FsExtraModule['readJSONSync'];
+    export const readJsonSync: FsExtraModule['readJsonSync'];
+    export const removeSync: FsExtraModule['removeSync'];
+    export const statSync: FsExtraModule['statSync'];
+    export const writeJSONSync: FsExtraModule['writeJSONSync'];
+}
+
+declare module 'jstoxml' {
+    export const toXML: (value: Record<string, unknown>, options?: Record<string, unknown>) => string;
+}
+
 declare module 'stopword' {
     export const eng: string[];
     export function removeStopwords(words: string[], stopwords?: string[]): string[];