proteum 1.0.3 → 2.0.0

package/cli/paths.ts

@@ -7,7 +7,6 @@ import fs from 'fs';
 import path from 'path';
 import TsAlias from 'ts-alias';
 import moduleAlias from 'module-alias';
-import { filenameToImportName } from 'babel-plugin-glob-import';
 
 // Core
 
@@ -19,23 +18,22 @@ import type { App } from './app';
 import type { TAppSide } from './app';
 
 export type TPathInfosOptions = {
-    basePath?: string,
-    shortenExtensions: string[],
+    basePath?: string;
+    shortenExtensions: string[];
     // Indexed will be trimed only when the extension can be shorten
-    trimIndex: boolean,
-}
+    trimIndex: boolean;
+};
 
 export type TPathInfos = {
-
-    original: string,
-    absolute: string,
-    relative: string,
+    original: string;
+    absolute: string;
+    relative: string;
     //forImport: string,
 
-    name: string,
-    extension: string,
-    isIndex: boolean
-}
+    name: string;
+    extension: string;
+    isIndex: boolean;
+};
 
 /*----------------------------------
 - CONFIG
@@ -43,10 +41,7 @@ export type TPathInfos = {
 
 export const staticAssetName = /*isDebug ? '[name].[ext].[hash:8]' :*/ '[hash:8][ext]';
 
-const pathInfosDefaultOpts = {
-    shortenExtensions: ['ts', 'js', 'tsx', 'jsx'],
-    trimIndex: true,
-}
+const pathInfosDefaultOpts = { shortenExtensions: ['ts', 'js', 'tsx', 'jsx'], trimIndex: true };
 
 const resolveCoreRoot = (appRoot: string) => {
     const localInstall = path.join(appRoot, 'node_modules', 'proteum');
@@ -55,66 +50,62 @@ const resolveCoreRoot = (appRoot: string) => {
     // When running `npx`/global installs, there may be no local `node_modules/proteum` yet.
     // Fall back to the installed package root (this file lives in `<root>/cli`).
     return path.resolve(__dirname, '..');
-}
+};
+
+const normalizeImportPath = (value: string) => value.replace(/\\/g, '/');
+
+const filenameToImportName = (value: string) =>
+    normalizeImportPath(value).replace(/[^A-Za-z0-9_]+/g, '_');
 
 /*----------------------------------
 - LIB
 ----------------------------------*/
 export default class Paths {
-
     /*----------------------------------
     - LISTE
     ----------------------------------*/
 
-    public constructor( 
+    public constructor(
         public appRoot: string,
-        public coreRoot = resolveCoreRoot(appRoot)
-    ) {
-        
-    }
+        public coreRoot = resolveCoreRoot(appRoot),
+    ) {}
 
-    public core = {
-        cli: path.resolve(__dirname, '.'),
-        root: this.coreRoot,
-        pages: this.coreRoot + '/client/pages',
-    }
+    public core = { cli: path.resolve(__dirname, '.'), root: this.coreRoot, pages: this.coreRoot + '/client/pages' };
 
     /*----------------------------------
     - EXTRACTION
     ----------------------------------*/
 
     public infos(filename: string, givenOpts: Partial<TPathInfosOptions> = {}): TPathInfos {
-
-        const opts: TPathInfosOptions = { ...pathInfosDefaultOpts, ...givenOpts }
+        const opts: TPathInfosOptions = { ...pathInfosDefaultOpts, ...givenOpts };
 
         // Extraction élements du chemin
-        const decomp = filename.split('/')
-        let [nomFichier, extension] = (decomp.pop() as string).split('.');
+        const decomp = filename.split('/');
+        const nomComplet = decomp.pop() as string;
+        const lastDotIndex = nomComplet.lastIndexOf('.');
+        const nomFichier = lastDotIndex === -1 ? nomComplet : nomComplet.substring(0, lastDotIndex);
+        const extension = lastDotIndex === -1 ? '' : nomComplet.substring(lastDotIndex + 1);
         const shortenExtension = opts.shortenExtensions && opts.shortenExtensions.includes(extension);
 
         // Vire l'index
-        const isIndex = nomFichier === 'index'
+        const isIndex = nomFichier === 'index';
         let cheminAbsolu: string;
         let nomReel: string;
         if (isIndex && shortenExtension && opts.trimIndex) {
             cheminAbsolu = decomp.join('/');
             nomReel = decomp.pop() as string;
         } else {
-            cheminAbsolu = [...decomp, nomFichier].join('/')
-            nomReel = nomFichier
+            cheminAbsolu = [...decomp, nomFichier].join('/');
+            nomReel = nomFichier;
         }
 
         // Conserve l'extension si nécessaire
-        if (!shortenExtension)
-            cheminAbsolu += '.' + extension;
+        if (!shortenExtension) cheminAbsolu += '.' + extension;
 
-        const relative = opts.basePath === undefined 
-            ? ''
-            : cheminAbsolu.substring( opts.basePath.length + 1 )
+        const relative = opts.basePath === undefined ? '' : cheminAbsolu.substring(opts.basePath.length + 1);
 
         // Retour
         const retour = {
-
             original: filename,
             absolute: cheminAbsolu,
             relative,
@@ -124,16 +115,15 @@ export default class Paths {
 
             name: nomReel,
             extension,
-            isIndex
-        }
+            isIndex,
+        };
 
         return retour;
     }
 
-    public getPageChunk( app: App, file: string ) {
-
-        const infos = this.infos( file, {
-            basePath: file.startsWith( app.paths.pages ) ? app.paths.pages : this.core.pages,
+    public getPageChunk(app: App, file: string) {
+        const infos = this.infos(file, {
+            basePath: file.startsWith(app.paths.pages) ? app.paths.pages : this.core.pages,
             // Avoid potential conflicts between /landing.tsx and /landing/index.tsx
             trimIndex: false,
         });
@@ -145,21 +135,25 @@ export default class Paths {
         let chunkId = filenameToImportName(filepath);
 
         // nsure it's non-empty
-        if (chunkId.length === 0) // = /index.tsx
-            chunkId = "main";
+        if (chunkId.length === 0)
+            // = /index.tsx
+            chunkId = 'main';
 
-        return { filepath, chunkId }
+        return { filepath, chunkId };
+    }
 
+    public getLayoutChunk(app: App, file: string) {
+        const layoutDir = path.dirname(path.dirname(file));
+        const relativeLayoutDir = path.relative(app.paths.pages, layoutDir);
+        const filepath = relativeLayoutDir === '' ? '' : normalizeImportPath(relativeLayoutDir);
+
+        return { filepath, chunkId: filenameToImportName(filepath) };
     }
 
     public applyAliases() {
-
-        const aliases = new TsAlias({
-            rootDir: this.core.cli
-        });
+        const aliases = new TsAlias({ rootDir: this.core.cli });
 
         //console.log('Applying Aliases ...', aliases.forModuleAlias());
-        moduleAlias.addAliases( aliases.forModuleAlias() );
-
+        moduleAlias.addAliases(aliases.forModuleAlias());
     }
 }

package/cli/print.ts

@@ -1,12 +1,18 @@
-export const h1 = (titre: string) => console.log(
-    '\n' +
-    '######################################################\n' +
-    '# ' + titre.toUpperCase() + '\n' +
-    '######################################################'
-);
+export const h1 = (titre: string) =>
+    console.log(
+        '\n' +
+            '######################################################\n' +
+            '# ' +
+            titre.toUpperCase() +
+            '\n' +
+            '######################################################',
+    );
 
-export const h2 = (titre: string) => console.log(
-    '------------------------------------------------------\n' +
-    '> ' + titre.toUpperCase() + '\n' +
-    '------------------------------------------------------'
-);
+export const h2 = (titre: string) =>
+    console.log(
+        '------------------------------------------------------\n' +
+            '> ' +
+            titre.toUpperCase() +
+            '\n' +
+            '------------------------------------------------------',
+    );

package/cli/tsconfig.json

@@ -10,13 +10,14 @@
         "skipLibCheck": true,
         "allowJs": true,
         "strict": false,
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictBindCallApply": true,
+        "useUnknownInCatchVariables": true,
         "downlevelIteration": true,
 
-        // Equivalent webpack: resolve.symblinks = false
+        // Keep symlinked package paths stable for local framework development.
         "preserveSymlinks": true,
-        // Décorateurs
-        "experimentalDecorators": true,
-
         // React
         "jsx": "react-jsx",
         "jsxImportSource": "preact",

package/cli/utils/agents.ts

@@ -0,0 +1,100 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import fs from 'fs-extra';
+import path from 'path';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TEnsureProjectAgentSymlinksArgs = { appRoot: string; coreRoot: string };
+
+type TAgentLinkDefinition = { projectPath: string; sourcePath: string; ensureParentDir?: boolean };
+
+/*----------------------------------
+- CONSTANTS
+----------------------------------*/
+
+// Project-local AGENTS entrypoints mapped to their framework-owned source files.
+const codexAgentLinkDefinitions: TAgentLinkDefinition[] = [
+    { projectPath: 'AGENTS.md', sourcePath: 'AGENTS.md' },
+    { projectPath: 'CODING_STYLE.md', sourcePath: 'CODING_STYLE.md' },
+    { projectPath: path.join('client', 'AGENTS.md'), sourcePath: path.join('client', 'AGENTS.md') },
+    { projectPath: path.join('client', 'pages', 'AGENTS.md'), sourcePath: path.join('client', 'pages', 'AGENTS.md') },
+    {
+        projectPath: path.join('server', 'services', 'AGENTS.md'),
+        sourcePath: path.join('server', 'services', 'AGENTS.md'),
+    },
+    { projectPath: path.join('server', 'routes', 'AGENTS.md'), sourcePath: path.join('server', 'routes', 'AGENTS.md') },
+    { projectPath: path.join('tests', 'e2e', 'AGENTS.md'), sourcePath: path.join('tests', 'AGENTS.md') },
+];
+
+/*----------------------------------
+- PUBLIC API
+----------------------------------*/
+
+export function ensureProjectAgentSymlinks({ appRoot, coreRoot }: TEnsureProjectAgentSymlinksArgs) {
+    const agentSourceRoot = path.join(coreRoot, 'agents', 'codex');
+    const agentLinks = codexAgentLinkDefinitions.map((linkDefinition) => ({
+        ...linkDefinition,
+        sourcePath: path.join(agentSourceRoot, linkDefinition.sourcePath),
+    }));
+
+    ensureSymlinks(appRoot, agentLinks, '[agents]');
+    ensureProjectSkillSymlinks({ appRoot, coreRoot });
+}
+
+/*----------------------------------
+- HELPERS
+----------------------------------*/
+
+function ensureProjectSkillSymlinks({ appRoot, coreRoot }: TEnsureProjectAgentSymlinksArgs) {
+    const frameworkSkillsRoot = path.join(coreRoot, 'skills');
+    if (!fs.existsSync(frameworkSkillsRoot)) return;
+
+    const skillLinks: TAgentLinkDefinition[] = fs
+        .readdirSync(frameworkSkillsRoot, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => ({
+            projectPath: path.join('skills', dirent.name),
+            sourcePath: path.join(frameworkSkillsRoot, dirent.name),
+            ensureParentDir: true,
+        }))
+        .filter((linkDefinition) => pathEntryExists(path.join(linkDefinition.sourcePath, 'SKILL.md')));
+
+    ensureSymlinks(appRoot, skillLinks, '[skills]');
+}
+
+function ensureSymlinks(appRoot: string, linkDefinitions: TAgentLinkDefinition[], logPrefix: string) {
+    for (const linkDefinition of linkDefinitions) {
+        const projectFilepath = path.join(appRoot, linkDefinition.projectPath);
+        const projectParentDir = path.dirname(projectFilepath);
+
+        if (linkDefinition.ensureParentDir) fs.ensureDirSync(projectParentDir);
+        else if (!fs.existsSync(projectParentDir)) continue;
+
+        if (pathEntryExists(projectFilepath)) continue;
+
+        const sourceFilepath = linkDefinition.sourcePath;
+        if (!fs.existsSync(sourceFilepath)) {
+            throw new Error(`Missing framework asset: ${sourceFilepath}`);
+        }
+
+        const symlinkTarget = path.relative(projectParentDir, sourceFilepath);
+        fs.symlinkSync(symlinkTarget, projectFilepath);
+
+        console.info(`${logPrefix} Created ${path.relative(appRoot, projectFilepath) || '.'} -> ${symlinkTarget}`);
+    }
+}
+
+function pathEntryExists(filepath: string) {
+    try {
+        fs.lstatSync(filepath);
+        return true;
+    } catch {
+        return false;
+    }
+}

package/cli/utils/check.ts

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import path from 'path';
+
+import cli from '..';
+import Compiler from '../compiler';
+import { runProcess } from './runProcess';
+
+const tsconfigPaths = ['client/tsconfig.json', 'server/tsconfig.json'];
+const eslintConfigPaths = ['eslint.config.mjs', 'eslint.config.js', 'eslint.config.cjs'];
+
+const resolveInstalledBinary = (name: string) => {
+    const binary = path.join(cli.paths.core.root, 'node_modules', '.bin', name);
+
+    if (!fs.existsSync(binary)) throw new Error(`Missing required binary "${name}" in Proteum dependencies.`);
+
+    return binary;
+};
+
+const resolveExistingAppPaths = (paths: string[]) =>
+    paths
+        .map((relativePath) => ({ relativePath, absolutePath: path.join(cli.paths.appRoot, relativePath) }))
+        .filter(({ absolutePath }) => fs.existsSync(absolutePath));
+
+const getTypecheckEnv = () => {
+    const existingNodeOptions = process.env.NODE_OPTIONS ?? '';
+
+    if (existingNodeOptions.includes('max-old-space-size')) return {};
+
+    return {
+        NODE_OPTIONS: [existingNodeOptions, '--max-old-space-size=8192'].filter(Boolean).join(' '),
+    };
+};
+
+export const refreshGeneratedTypings = async () => {
+    const compiler = new Compiler('dev');
+
+    await compiler.refreshGeneratedTypings();
+};
+
+export const runAppTypecheck = async () => {
+    const existingProjects = resolveExistingAppPaths(tsconfigPaths);
+
+    if (existingProjects.length === 0)
+        throw new Error(`No TypeScript app projects found. Expected one of: ${tsconfigPaths.join(', ')}.`);
+
+    const tsc = resolveInstalledBinary('tsc');
+
+    for (const { relativePath } of existingProjects)
+        await runProcess(tsc, ['-p', relativePath, '--noEmit', '--pretty', 'false'], {
+            cwd: cli.paths.appRoot,
+            env: getTypecheckEnv(),
+        });
+};
+
+export const runAppLint = async ({ fix = false } = {}) => {
+    const [config] = resolveExistingAppPaths(eslintConfigPaths);
+
+    if (!config)
+        throw new Error(
+            `No ESLint config found. Expected one of: ${eslintConfigPaths
+                .map((relativePath) => path.join(cli.paths.appRoot, relativePath))
+                .join(', ')}.`,
+        );
+
+    const eslint = resolveInstalledBinary('eslint');
+    const args = ['.', '--config', config.absolutePath, '--no-config-lookup'];
+
+    if (fix) args.push('--fix');
+
+    await runProcess(eslint, args, { cwd: cli.paths.appRoot });
+};

package/cli/utils/index.ts

@@ -6,12 +6,10 @@
 import fs from 'fs-extra';
 import path from 'path';
 
-
 /*----------------------------------
 - TYPES
 ----------------------------------*/
 
-
 /*----------------------------------
 - UTILS
 ----------------------------------*/
@@ -19,4 +17,4 @@ import path from 'path';
 export const api = (method: string, path: string, data: object, local: boolean = false) =>
     `curl -X ${method} ${local ? 'http://localhost:3010' : 'https://dopamyn.io'}${path} ` +
     `-H 'Content-Type: application/json' -H 'Accept: application/json' ` +
-    `-d '${JSON.stringify(data)}';`;
+    `-d '${JSON.stringify(data)}';`;

package/cli/utils/keyboard.ts

@@ -9,28 +9,22 @@ import readline, { Key } from 'readline';
 - TYPES
 ----------------------------------*/
 
-type TKeyboardCommand = {
-    remove?: boolean,
-    run: (str: string, chunk: string, key: Key) => void
-}
+type TKeyboardCommand = { remove?: boolean; run: (str: string, chunk: string, key: Key) => void };
 
 /*----------------------------------
 - METHODS
 ----------------------------------*/
 class KeyboardCommands {
-
-    private commands: { [input: string]: TKeyboardCommand } = {}
+    private commands: { [input: string]: TKeyboardCommand } = {};
 
     public constructor() {
         this.listen();
     }
 
     private listen() {
-
         readline.emitKeypressEvents(process.stdin);
         process.stdin.setRawMode(true);
         process.stdin.on('keypress', async (chunk: string, key: Key) => {
-
             let str = key.name;
             if (!str) return;
             if (str === 'return') str = 'enter';
@@ -41,38 +35,27 @@ class KeyboardCommands {
 
             const kCommand = this.commands[str] || this.commands.fallback;
             if (kCommand) {
-
                 kCommand.run(str, chunk, key);
 
-                if (kCommand.remove)
-                    delete this.commands[str];
+                if (kCommand.remove) delete this.commands[str];
             }
 
             if (str === 'ctrl+c') {
-
                 console.log(`Exiting ...`);
                 process.exit(0);
-
-            } 
-
-
+            }
         });
     }
 
-
-    public input(str: string, run: TKeyboardCommand["run"], options: Omit<TKeyboardCommand, 'run'> = {}) {
-        this.commands[str] = { run, ...options }
+    public input(str: string, run: TKeyboardCommand['run'], options: Omit<TKeyboardCommand, 'run'> = {}) {
+        this.commands[str] = { run, ...options };
     }
 
     public waitForInput(str: string): Promise<void> {
         return new Promise((resolve) => {
-            this.commands[str] = {
-                run: () => resolve(),
-                remove: true
-            }
+            this.commands[str] = { run: () => resolve(), remove: true };
         });
     }
-
 }
 
-export default new KeyboardCommands
+export default new KeyboardCommands();

package/cli/utils/runProcess.ts

@@ -0,0 +1,30 @@
+import cp from 'child_process';
+
+type TRunProcessOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+};
+
+export const runProcess = (command: string, args: string[] = [], options: TRunProcessOptions = {}) =>
+    new Promise<void>((resolve, reject) => {
+        const child = cp.spawn(command, args, {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: 'inherit',
+        });
+
+        child.on('error', reject);
+        child.on('exit', (code, signal) => {
+            if (signal) {
+                reject(new Error(`Command "${command}" was interrupted by signal ${signal}.`));
+                return;
+            }
+
+            if (code === 0) {
+                resolve();
+                return;
+            }
+
+            reject(new Error(`Command "${command}" exited with code ${code ?? 'unknown'}.`));
+        });
+    });

package/client/app/component.tsx

@@ -7,48 +7,48 @@ import React from 'react';
 
 // Core
 import type { Layout } from '@common/router';
-import { ReactClientContext } from '@/client/context';
-import DialogManager from '@client/components/Dialog/Manager'
+import type { LayoutProps } from '@common/router/layouts';
+import { ReactClientContext, type ClientContext } from '@/client/context';
+import DialogManager from '@client/components/Dialog/Manager';
 
 // Core components
 import RouterComponent from '@client/services/router/components/router';
-import type { TClientOrServerContextForPage } from '@common/router';
 
 /*----------------------------------
 - COMPOSANT
 ----------------------------------*/
-export default function App({ context }: {
-    context: TClientOrServerContextForPage,
-}) {
-
+export default function App({ context }: { context: ClientContext }) {
     const curLayout = context.page?.layout;
     const [layout, setLayout] = React.useState<Layout | false | undefined>(curLayout);
     const [apiData, setApiData] = React.useState<{ [k: string]: any } | null>(context.page?.data || {});
 
     // TODO: context.page is always provided in the context on the client side
-    if (context.app.side === "client")
-        context.app.setLayout = setLayout;
+    if (context.app.side === 'client') context.app.setLayout = setLayout;
+
+    const layoutProps: LayoutProps = {
+        ...context,
+        context,
+        data: { ...apiData, ...context.request.data },
+        menu: undefined,
+        children: undefined,
+    };
 
     return (
         <ReactClientContext.Provider value={context}>
-
-            <DialogManager context={context} />
-
-            {!layout ? <>
-                {/* TODO: move to app, because here, we're not aware that the router service has been defined */}
-                <RouterComponent service={context.Router} />
-            </> : <> {/* Same as router/components/Page.tsx */}
-                <layout.Component
-                    // Services
-                    {...context}
-                    // API data & URL params
-                    data={{
-                        ...apiData,
-                        ...context.request.data
-                    }}
-                />
-            </>}
-
+            <DialogManager />
+
+            {!layout ? (
+                <>
+                    {/* TODO: move to app, because here, we're not aware that the router service has been defined */}
+                    <RouterComponent service={context.Router} />
+                </>
+            ) : (
+                <>
+                    {' '}
+                    {/* Same as router/components/Page.tsx */}
+                    <layout.Component {...layoutProps} />
+                </>
+            )}
         </ReactClientContext.Provider>
-    )
-}
+    );
+}