proteum 1.0.2 → 2.0.0-1

package/scripts/refactor-server-runtime-aliases.ts

@@ -0,0 +1,360 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { parse } from '@babel/parser';
+import traverse, { NodePath } from '@babel/traverse';
+import generate from '@babel/generator';
+import * as types from '@babel/types';
+
+type TRuntimeImportSource = '@app' | '@request' | '@models';
+
+type TRuntimeBinding = { local: string; imported: string; source: TRuntimeImportSource };
+
+type TClassContext = { hasApp: boolean; hasRequest: boolean };
+
+const fallbackBindings = new Map<string, TRuntimeBinding>([
+    ['Models', { local: 'Models', imported: 'Models', source: '@app' }],
+    ['Disks', { local: 'Disks', imported: 'Disks', source: '@app' }],
+    ['Router', { local: 'Router', imported: 'Router', source: '@app' }],
+    ['Environment', { local: 'Environment', imported: 'Environment', source: '@app' }],
+    ['Identity', { local: 'Identity', imported: 'Identity', source: '@app' }],
+    ['auth', { local: 'auth', imported: 'auth', source: '@request' }],
+    ['context', { local: 'context', imported: 'context', source: '@request' }],
+]);
+
+const parseCode = (code: string, filename: string) =>
+    parse(code, {
+        sourceType: 'module',
+        sourceFilename: filename,
+        plugins: [
+            'typescript',
+            'jsx',
+            'decorators-legacy',
+            'classProperties',
+            'classPrivateProperties',
+            'classPrivateMethods',
+        ],
+    });
+
+const findFiles = (dir: string): string[] => {
+    if (!fs.existsSync(dir)) return [];
+
+    const files: string[] = [];
+
+    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const filepath = path.join(dir, dirent.name);
+
+        if (dirent.isDirectory()) {
+            files.push(...findFiles(filepath));
+            continue;
+        }
+
+        if (dirent.isFile() && /\.(tsx?|jsx?)$/.test(filepath) && !filepath.endsWith('.d.ts')) files.push(filepath);
+    }
+
+    return files;
+};
+
+const lowerFirst = (value: string) => (value.length ? value[0].toLowerCase() + value.substring(1) : value);
+
+const getOriginalFileContent = (repoRoot: string, filepath: string) => {
+    const relativeFilepath = path.relative(repoRoot, filepath).replace(/\\/g, '/');
+
+    try {
+        return execFileSync('git', ['-C', repoRoot, 'show', `HEAD:${relativeFilepath}`], { encoding: 'utf8' });
+    } catch {
+        return null;
+    }
+};
+
+const extractRuntimeBindings = (code: string, filename: string) => {
+    const ast = parseCode(code, filename);
+    const runtimeBindings = new Map<string, TRuntimeBinding>();
+
+    traverse(ast, {
+        ImportDeclaration(importPath) {
+            const source = importPath.node.source.value;
+            if (source !== '@app' && source !== '@request' && source !== '@models') return;
+
+            for (const specifier of importPath.node.specifiers) {
+                if (specifier.type !== 'ImportSpecifier' || specifier.imported.type !== 'Identifier') continue;
+
+                runtimeBindings.set(specifier.local.name, {
+                    local: specifier.local.name,
+                    imported: specifier.imported.name,
+                    source,
+                });
+            }
+        },
+    });
+
+    return runtimeBindings;
+};
+
+const getClassContext = (path: NodePath) => {
+    const classPath = path.findParent((parentPath) => parentPath.isClass()) as NodePath<types.Class> | null;
+    if (!classPath) return null;
+
+    const classNode = classPath.node;
+    let hasApp = false;
+    let hasRequest = false;
+
+    if (
+        types.isIdentifier(classNode.superClass) &&
+        (classNode.superClass.name === 'Service' ||
+            classNode.superClass.name === 'Controller' ||
+            classNode.superClass.name.endsWith('Service') ||
+            classNode.superClass.name.endsWith('Controller'))
+    ) {
+        hasApp = true;
+        hasRequest = true;
+    }
+
+    if (classNode.superClass) {
+        hasApp = true;
+        hasRequest = true;
+    }
+
+    for (const member of classNode.body.body) {
+        if (
+            (types.isClassProperty(member) || types.isClassAccessorProperty?.(member)) &&
+            types.isIdentifier(member.key)
+        ) {
+            if (member.key.name === 'app') hasApp = true;
+            if (member.key.name === 'request') hasRequest = true;
+        }
+
+        if (types.isClassMethod(member) && types.isIdentifier(member.key)) {
+            if (member.kind === 'get' && member.key.name === 'request') hasRequest = true;
+
+            if (member.kind === 'constructor') {
+                for (const param of member.params) {
+                    if (types.isTSParameterProperty(param)) {
+                        const parameter = param.parameter;
+                        const identifier = types.isIdentifier(parameter)
+                            ? parameter
+                            : types.isAssignmentPattern(parameter) && types.isIdentifier(parameter.left)
+                              ? parameter.left
+                              : null;
+
+                        if (!identifier) continue;
+
+                        if (identifier.name === 'app') hasApp = true;
+                        if (identifier.name === 'request') hasRequest = true;
+                    } else if (types.isIdentifier(param)) {
+                        if (param.name === 'app') hasApp = true;
+                        if (param.name === 'request') hasRequest = true;
+                    }
+                }
+            }
+        }
+    }
+
+    traverse(classPath.node, {
+        noScope: true,
+        MemberExpression(memberPath) {
+            if (!types.isThisExpression(memberPath.node.object)) return;
+            if (!types.isIdentifier(memberPath.node.property)) return;
+
+            if (memberPath.node.property.name === 'app') hasApp = true;
+            if (memberPath.node.property.name === 'request') hasRequest = true;
+        },
+    });
+
+    if (!hasApp && !hasRequest) return null;
+
+    return { hasApp, hasRequest } satisfies TClassContext;
+};
+
+const isInTypePosition = (path: NodePath<types.Identifier>) => {
+    let current: NodePath | null = path;
+
+    while (current?.parentPath) {
+        const parent = current.parentPath;
+
+        if (
+            (parent.isTSAsExpression() ||
+                parent.isTSSatisfiesExpression() ||
+                parent.isTSNonNullExpression() ||
+                parent.isTSInstantiationExpression()) &&
+            current.key === 'expression'
+        ) {
+            current = parent;
+            continue;
+        }
+
+        if (parent.node.type.startsWith('TS')) return true;
+
+        if (
+            parent.isExpression() ||
+            parent.isStatement() ||
+            parent.isProgram() ||
+            parent.isClassBody() ||
+            parent.isClassMethod() ||
+            parent.isClassProperty() ||
+            parent.isObjectProperty()
+        )
+            return false;
+
+        current = parent;
+    }
+
+    return false;
+};
+
+const isSafeImportBinding = (bindingPath: NodePath) => {
+    if (
+        !bindingPath.isImportSpecifier() &&
+        !bindingPath.isImportNamespaceSpecifier() &&
+        !bindingPath.isImportDefaultSpecifier()
+    )
+        return false;
+
+    const importDeclaration = bindingPath.parentPath;
+    if (!importDeclaration?.isImportDeclaration()) return false;
+
+    if (importDeclaration.node.importKind === 'type') return true;
+    if (importDeclaration.node.source.value === '@models/types') return true;
+
+    return false;
+};
+
+const buildReplacementExpression = (binding: TRuntimeBinding, classContext: TClassContext | null) => {
+    if (!classContext) return null;
+
+    if (binding.source === '@request') {
+        if (!classContext.hasRequest) return null;
+
+        if (binding.imported === 'context')
+            return types.memberExpression(types.thisExpression(), types.identifier('request'));
+
+        return types.memberExpression(
+            types.memberExpression(types.thisExpression(), types.identifier('request')),
+            types.identifier(binding.imported),
+        );
+    }
+
+    if (!classContext.hasApp) return null;
+
+    if (binding.source === '@app') {
+        if (binding.imported === 'Environment')
+            return types.memberExpression(
+                types.memberExpression(types.thisExpression(), types.identifier('app')),
+                types.identifier('env'),
+            );
+
+        if (binding.imported === 'Identity')
+            return types.memberExpression(
+                types.memberExpression(types.thisExpression(), types.identifier('app')),
+                types.identifier('identity'),
+            );
+
+        return types.memberExpression(
+            types.memberExpression(types.thisExpression(), types.identifier('app')),
+            types.identifier(binding.imported),
+        );
+    }
+
+    return types.memberExpression(
+        types.memberExpression(
+            types.memberExpression(
+                types.memberExpression(types.thisExpression(), types.identifier('app')),
+                types.identifier('Models'),
+            ),
+            types.identifier('client'),
+        ),
+        types.identifier(lowerFirst(binding.imported)),
+    );
+};
+
+const repoRoots = process.argv.slice(2);
+if (!repoRoots.length)
+    throw new Error('Usage: ts-node scripts/refactor-server-runtime-aliases.ts <repo-root> [repo-root...]');
+
+for (const repoRoot of repoRoots) {
+    const serviceRoot = path.join(repoRoot, 'server', 'services');
+    const files = findFiles(serviceRoot).filter((filepath) => !filepath.endsWith('.controller.ts'));
+
+    let changedFiles = 0;
+    let replacementCount = 0;
+    const skipped: string[] = [];
+
+    for (const filepath of files) {
+        const originalCode = getOriginalFileContent(repoRoot, filepath);
+        if (!originalCode) continue;
+
+        const runtimeBindings = extractRuntimeBindings(originalCode, filepath);
+        if (!runtimeBindings.size) continue;
+
+        const code = fs.readFileSync(filepath, 'utf8');
+        const ast = parseCode(code, filepath);
+        let fileChanged = false;
+
+        traverse(ast, {
+            MemberExpression(memberPath) {
+                if (!types.isMemberExpression(memberPath.node.object)) return;
+                if (!types.isThisExpression(memberPath.node.object.object)) return;
+                if (!types.isIdentifier(memberPath.node.object.property, { name: 'app' })) return;
+                if (!types.isIdentifier(memberPath.node.property)) return;
+
+                if (memberPath.node.property.name === 'Environment') {
+                    memberPath.node.property = types.identifier('env');
+                    fileChanged = true;
+                }
+
+                if (memberPath.node.property.name === 'Identity') {
+                    memberPath.node.property = types.identifier('identity');
+                    fileChanged = true;
+                }
+            },
+            Identifier(identifierPath) {
+                const binding =
+                    runtimeBindings.get(identifierPath.node.name) || fallbackBindings.get(identifierPath.node.name);
+                if (!binding) return;
+                if (!identifierPath.isReferencedIdentifier()) return;
+                if (isInTypePosition(identifierPath)) return;
+
+                const currentBinding = identifierPath.scope.getBinding(identifierPath.node.name);
+                if (currentBinding && !isSafeImportBinding(currentBinding.path)) return;
+
+                const classContext = getClassContext(identifierPath);
+                const replacement = buildReplacementExpression(binding, classContext);
+                if (!replacement) {
+                    const location = identifierPath.node.loc?.start;
+                    skipped.push(
+                        `${path.relative(repoRoot, filepath)}:${location?.line ?? 0}:${identifierPath.node.name}`,
+                    );
+                    return;
+                }
+
+                if (
+                    identifierPath.parentPath?.isObjectProperty() &&
+                    identifierPath.parentPath.node.shorthand &&
+                    identifierPath.parentKey === 'value'
+                ) {
+                    identifierPath.parentPath.node.shorthand = false;
+                }
+
+                identifierPath.replaceWith(types.cloneNode(replacement, true));
+                fileChanged = true;
+                replacementCount += 1;
+            },
+        });
+
+        if (!fileChanged) continue;
+
+        const output = generate(ast, { retainLines: false, decoratorsBeforeExport: true }, code).code;
+
+        fs.writeFileSync(filepath, output + '\n');
+        changedFiles += 1;
+    }
+
+    console.info(`[runtime-aliases] ${repoRoot}: changed ${changedFiles} files, ${replacementCount} replacements`);
+
+    if (skipped.length) {
+        console.info('[runtime-aliases] skipped references:');
+        for (const item of skipped.slice(0, 50)) console.info(' -', item);
+
+        if (skipped.length > 50) console.info(` - ... ${skipped.length - 50} more`);
+    }
+}

package/scripts/restore-client-app-import-files.ts

@@ -0,0 +1,41 @@
+import { execFileSync } from 'child_process';
+import path from 'path';
+import fs from 'fs-extra';
+
+const repoRoots = process.argv.slice(2);
+if (!repoRoots.length)
+    throw new Error('Usage: ts-node scripts/restore-client-app-import-files.ts <repo-root> [repo-root...]');
+
+for (const repoRoot of repoRoots) {
+    const diffOutput = execFileSync(
+        'git',
+        ['-C', repoRoot, 'diff', '--name-only', 'HEAD', '--', 'client/components', 'client/hooks'],
+        { encoding: 'utf8' },
+    );
+    const currentDiffFiles = diffOutput
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+
+    const grepOutput = execFileSync(
+        'git',
+        ['-C', repoRoot, 'grep', '-l', `from '@app'\\|from "@app"`, 'HEAD', '--', 'client'],
+        { encoding: 'utf8' },
+    );
+    const headAppImportFiles = new Set(
+        grepOutput
+            .split('\n')
+            .map((line) => line.trim().replace(/^HEAD:/, ''))
+            .filter((line) => line.startsWith('client/components/') || line.startsWith('client/hooks/')),
+    );
+
+    const filesToRestore = currentDiffFiles.filter((filepath) => headAppImportFiles.has(filepath));
+
+    for (const relativeFile of filesToRestore) {
+        const nextContent = execFileSync('git', ['-C', repoRoot, 'show', `HEAD:${relativeFile}`], { encoding: 'utf8' });
+        const filepath = path.join(repoRoot, relativeFile);
+        fs.ensureDirSync(path.dirname(filepath));
+        fs.writeFileSync(filepath, nextContent);
+        console.log(`[restore-client-app-import-files] restored ${filepath}`);
+    }
+}

package/scripts/restore-files-from-git-head.ts

@@ -0,0 +1,20 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execFileSync } from 'child_process';
+
+const args = process.argv.slice(2);
+if (args.length < 2)
+    throw new Error(
+        'Usage: ts-node scripts/restore-files-from-git-head.ts <repo-root> <relative-file> [relative-file...]',
+    );
+
+const [repoRoot, ...relativeFiles] = args;
+
+for (const relativeFile of relativeFiles) {
+    const nextContent = execFileSync('git', ['-C', repoRoot, 'show', `HEAD:${relativeFile}`], { encoding: 'utf8' });
+
+    const filepath = path.join(repoRoot, relativeFile);
+    fs.ensureDirSync(path.dirname(filepath));
+    fs.writeFileSync(filepath, nextContent);
+    console.log(`[restore-files-from-git-head] restored ${filepath}`);
+}

package/scripts/update-codex-agents.ts

@@ -0,0 +1,35 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import path from 'path';
+
+// Core
+import { ensureProjectAgentSymlinks } from '../cli/utils/agents';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TInputRoot = string | undefined;
+
+/*----------------------------------
+- MAIN PROCESS
+----------------------------------*/
+
+const proteumRoot = path.resolve(__dirname, '..');
+const inputRoots = process.argv.slice(2) as TInputRoot[];
+const projectRoots = (inputRoots.length === 0 ? [process.cwd()] : inputRoots).map((inputRoot) =>
+    path.resolve(inputRoot || process.cwd()),
+);
+
+for (const projectRoot of projectRoots) {
+    if (projectRoot === proteumRoot) {
+        console.warn(`[update-codex-agents] Skipping Proteum root: ${projectRoot}`);
+        continue;
+    }
+
+    console.log(`[update-codex-agents] Syncing project Codex assets in ${projectRoot}`);
+    ensureProjectAgentSymlinks({ appRoot: projectRoot, coreRoot: proteumRoot });
+}

package/server/app/commands.ts

@@ -6,7 +6,7 @@
 import yargsParser from 'yargs-parser';
 
 // Core
-import type { Application } from '@server/app';
+import type { Application } from './index';
 import Service from '@server/app/service';
 import { NotFound } from '@common/errors';
 
@@ -14,18 +14,16 @@ import { NotFound } from '@common/errors';
 - TYPES
 ----------------------------------*/
 
-type CommandCallback<TArgs extends any[]> = (...args: TArgs) => Promise<any>
+type CommandCallback<TArgs extends any[]> = (...args: TArgs) => Promise<any>;
 
-export type CommandsList = {
-    [commandName: string]: Command
-}
+export type CommandsList = { [commandName: string]: Command };
 
 export type Command<TArgs extends any[] = any[]> = {
-    name: string,
-    description: string,
-    run?: CommandCallback<TArgs>
-    childrens: CommandsList
-}
+    name: string;
+    description: string;
+    run?: CommandCallback<TArgs>;
+    childrens: CommandsList;
+};
 
 /*----------------------------------
 - SERVICE TYPES
@@ -33,59 +31,40 @@ export type Command<TArgs extends any[] = any[]> = {
 
 const LogPrefix = `[commands]`;
 
-export type Config = {
-    debug: boolean
-}
+export type Config = { debug: boolean };
 
-export type Hooks = {
-
-}
+export type Hooks = {};
 
-export type Services = {
-
-}
+export type Services = {};
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class CommandsManager extends Service<Config, Hooks, Application> {
-
     public priority = 2 as 2;
 
-    public commandsIndex: CommandsList = {}
-    
-    public command<TArgs extends any[]>( 
-        ...args: (
-            [name: string, description: string, childrens: Command[]]
-            |
-            [name: string, description: string, run: CommandCallback<TArgs>, childrens?: Command[]]
-        )
-    ): Command {
+    public commandsIndex: CommandsList = {};
 
+    public command<TArgs extends any[]>(
+        ...args:
+            | [name: string, description: string, childrens: Command[]]
+            | [name: string, description: string, run: CommandCallback<TArgs>, childrens?: Command[]]
+    ): Command {
         let name: string, description: string;
         let childrens: Command[] | undefined;
         let run: CommandCallback<TArgs> | undefined;
 
-        if (typeof args[2] === 'object')
-            ([name, description, childrens] = args)
-        else
-            ([name, description, run, childrens] = args)
-        
-        const command: Command = {
-            name,
-            description,
-            run, 
-            childrens: childrens ? this.indexFromList(childrens) : {}
-        }
+        if (typeof args[2] === 'object') [name, description, childrens] = args;
+        else [name, description, run, childrens] = args;
+
+        const command: Command = { name, description, run, childrens: childrens ? this.indexFromList(childrens) : {} };
 
         return command;
     }
 
-    private indexFromList( list: Command[] ): CommandsList {
-
-        const index: CommandsList = {}
-        for (const command of list)
-            index[ command.name ] = command;
+    private indexFromList(list: Command[]): CommandsList {
+        const index: CommandsList = {};
+        for (const command of list) index[command.name] = command;
 
         return index;
     }
@@ -93,49 +72,41 @@ export default class CommandsManager extends Service<Config, Hooks, Application>
     /*----------------------------------
     - REGISTER
     ----------------------------------*/
-    public fromList( list: Command[] ) {
+    public fromList(list: Command[]) {
         for (const command of list) {
-
-            if (this.commandsIndex[ command.name ] !== undefined)
+            if (this.commandsIndex[command.name] !== undefined)
                 throw new Error(`Tried to register command "${command.name}", but it already has been defined.`);
 
-            this.commandsIndex[ command.name ] = command;
+            this.commandsIndex[command.name] = command;
         }
     }
 
     /*----------------------------------
     - RUN
     ----------------------------------*/
-    public async run( commandString: string ) {
-
+    public async run(commandString: string) {
         const { _, ...args } = yargsParser(commandString);
 
         this.config.debug && console.log(LogPrefix, `Run command: ${commandString} | Parsed:`, { _, ...args });
 
         let command: Command | undefined;
         for (const commandName of _) {
-
-            const commandsList: CommandsList = command === undefined 
-                ? this.commandsIndex
-                : command.childrens;
+            const commandsList: CommandsList = command === undefined ? this.commandsIndex : command.childrens;
 
             command = commandsList[commandName];
 
-            if (command === undefined)
-                break;
+            if (command === undefined) break;
         }
 
-        if (command === undefined)
-            throw new NotFound(`Command not found.`);
+        if (command === undefined) throw new NotFound(`Command not found.`);
 
-        if (command.run === undefined)
-            throw new NotFound(`This command isn't runnable.`);
+        if (command.run === undefined) throw new NotFound(`This command isn't runnable.`);
 
         // TODO: order correctly & validate type according to injected typescript typedefs (command.run.params)
         const argsList = Object.values(args);
 
-        const result = await command.run(argsList);
+        const result = await command.run(...(argsList as Parameters<NonNullable<typeof command.run>>));
 
-        return result;    
+        return result;
     }
-}
+}