@creatorem/cli 0.0.1 → 1.0.4

package/src/mobile-features/organization/index.ts

@@ -0,0 +1,38 @@
+import { FeatureRemover } from '../types.js';
+
+export const MobileOrganizationFeature: FeatureRemover = {
+    key: 'organization',
+    cliUI: {
+        title: 'Organization',
+        features: [
+            'Database implementation',
+            'Role management',
+            'Member management',
+            'Built React logic (useOrganization, <OrganizationSwitcher />, ...)'
+        ]
+    },
+    dependenciesToRemove: ['@kit/organization'],
+    // Removes `import useOrgFilters from '@kit/organization/native/use-filters'`
+    // and the `useOrgFilters()` call from hooks/use-filters.ts
+    i18nNamespacePrefix: 'p_org',
+    useFilters: 'useOrgFilters',
+    // Also removes initOrgServerFilters() from apps/api/lib/init-server-filters.ts
+    // when create-mobile provisions the fallback API app.
+    serverFilter: 'initOrgServerFilters',
+    router: {
+        importName: 'organizationRouter',
+        importPath: '@kit/organization/router',
+    },
+    repo: {
+        filesToDelete: [
+            'supabase/schemas/030-organization-enums.sql',
+            'supabase/schemas/031-kit-org.sql',
+            'supabase/schemas/032-organization.sql',
+            'supabase/schemas/033-organization-roles.sql',
+            'supabase/schemas/034-organization-members.sql',
+            'supabase/schemas/035-organization-invitations.sql',
+            'supabase/schemas/036-organization-settings.sql',
+            'supabase/schemas/037-organization-notifications.sql',
+        ],
+    },
+};

package/src/mobile-features/types.ts

@@ -0,0 +1 @@
+export type { FeatureRemover } from '../dashboard-features/types.js';

package/src/shims/signal-exit.js

@@ -0,0 +1,9 @@
+// Bypass the alias by importing from the specific file in node_modules
+// We use a relative path that we hope resolves correctly from dist/
+// But since we are bundling, we need the path relative to THIS file (src/shims/signal-exit.js)
+// AND we need to make sure esbuild doesn't treat it as the aliased package.
+// Using a relative path to node_modules/signal-exit/dist/mjs/index.js usually works.
+import { onExit, load, unload } from '../../node_modules/signal-exit/dist/mjs/index.js';
+
+export default onExit;
+export { onExit, load, unload };

package/src/ui/app.tsx

@@ -0,0 +1,68 @@
+import React from 'react';
+import { Text, Box } from 'ink';
+import GenerateMigration from '../commands/generate-migration.js';
+import GenerateSchemas from '../commands/generate-schemas.js';
+import CreateDashboard from '../commands/create-dashboard.js';
+import CreateMobile from '../commands/create-mobile.js';
+import Create from '../commands/create.js';
+
+interface AppProps {
+    command?: string;
+    args?: string[];
+    flags?: Record<string, any>;
+}
+
+const App: React.FC<AppProps> = ({ command, args = [], flags = {} }) => {
+    if (!command) {
+        return (
+            <Box flexDirection="column">
+                <Text>Please specify a command.</Text>
+                <Text>Example: creatorem create-dashboard</Text>
+            </Box>
+        );
+    }
+
+    // The original code had a 'help' command check.
+    // Assuming the new instruction implies 'help' is now handled differently or not needed here.
+    // If 'help' is still a command, it would need its own 'if' block.
+    // For now, I'll keep the original 'help' output if command is 'help'
+    // and the new output if command is undefined.
+
+    if (command === 'help') {
+        return (
+            <Box flexDirection="column" padding={1}>
+                <Text color="green">Creatorem CLI</Text>
+                <Text>Run <Text color="cyan">creatorem --help</Text> to see available commands.</Text>
+            </Box>
+        );
+    }
+
+    if (command === 'generate-migration') {
+        return <GenerateMigration args={args} />;
+    }
+
+    if (command === 'generate-schemas') {
+        return <GenerateSchemas args={args} />;
+    }
+
+    if (command === 'create-dashboard') {
+        return <CreateDashboard args={args} flags={flags} />;
+    }
+
+    if (command === 'create-mobile') {
+        return <CreateMobile args={args} flags={flags} />;
+    }
+
+    if (command === 'create') {
+        return <Create args={args} flags={flags} />;
+    }
+
+    return (
+        <Box flexDirection="column" padding={1}>
+            <Text color="red">Unknown command: {command}</Text>
+            <Text>Run <Text color="cyan">creatorem --help</Text> to see available commands.</Text>
+        </Box>
+    );
+};
+
+export default App;

package/src/ui/multi-select.tsx

@@ -0,0 +1,106 @@
+import React, { useState, useRef } from 'react';
+import { Box, Text, useInput } from 'ink';
+
+interface Item {
+    label: string;
+    value: string;
+    title?: string;
+    description?: string;
+    features?: string[];
+}
+
+interface MultiSelectProps {
+    items: Item[];
+    initialSelectedValues?: string[];
+    onSubmit: (selected: string[]) => void;
+}
+
+export const MultiSelect: React.FC<MultiSelectProps> = ({
+    items,
+    initialSelectedValues = [],
+    onSubmit,
+}) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [selectedValues, setSelectedValues] = useState<string[]>(initialSelectedValues);
+    // Ref-based guard: prevents double-submit when terminal sends \r\n as two keypress events
+    const submittedRef = useRef(false);
+
+    useInput((input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex(prev => (prev > 0 ? prev - 1 : items.length - 1));
+        }
+
+        if (key.downArrow) {
+            setSelectedIndex(prev => (prev < items.length - 1 ? prev + 1 : 0));
+        }
+
+        if (input === ' ') {
+            const currentItem = items[selectedIndex];
+            if (selectedValues.includes(currentItem.value)) {
+                setSelectedValues(prev => prev.filter(v => v !== currentItem.value));
+            } else {
+                setSelectedValues(prev => [...prev, currentItem.value]);
+            }
+        }
+
+        if (key.return) {
+            if (submittedRef.current) return;
+            submittedRef.current = true;
+            onSubmit(selectedValues);
+        }
+    });
+
+    return (
+        <Box flexDirection="column">
+            {items.map((item, index) => {
+                const isSelected = selectedValues.includes(item.value);
+                const isFocused = index === selectedIndex;
+
+                return (
+                    <Box key={item.value} flexDirection="column">
+                        <Box>
+                            <Text color={isFocused ? 'cyan' : undefined}>
+                                {isFocused ? '> ' : '  '}
+                            </Text>
+                            <Text color={isSelected ? 'green' : undefined}>
+                                [{isSelected ? 'x' : ' '}] 
+                            </Text>
+                            {item.title ? (
+                                <Text bold>{item.title}</Text>
+                            ) : (
+                                <Text>{item.label}</Text>
+                            )}
+                        </Box>
+                        {isFocused && item.description ? (
+                            <Box paddingLeft={4}>
+                                <Text color="gray">{item.description}</Text>
+                            </Box>
+                        ) : null}
+                        {isFocused && item.features && item.features.length > 0 ? (
+                            <Box paddingLeft={4} flexDirection="column">
+                                {item.features.map(feature => (
+                                    <Text key={`${item.value}-${feature}`} color="gray">
+                                        - {feature}
+                                    </Text>
+                                ))}
+                            </Box>
+                        ) : null}
+                    </Box>
+                );
+            })}
+            <Box marginTop={1}>
+                {selectedValues.length === 0 ? (
+                    <Text color="gray">
+                        (Press space to select, enter to submit)
+                    </Text>
+                ) : (
+                    <Text color="green">
+                        (Press space to toggle, enter to submit)
+                    </Text>
+                )}
+            </Box>
+        </Box>
+    );
+};
+
+export default MultiSelect;

package/src/utils/ast.ts

@@ -0,0 +1,422 @@
+import { Project, SyntaxKind } from 'ts-morph';
+import fs from 'fs-extra';
+import path from 'path';
+
+export const createProject = () => {
+    return new Project({
+        skipAddingFilesFromTsConfig: true,
+    });
+};
+
+export const loadFile = (project: Project, filePath: string) => {
+    return project.addSourceFileAtPath(filePath);
+};
+
+export const removeImport = (sourceFile: any, moduleSpecifier: string) => {
+    const importDec = sourceFile.getImportDeclaration((i: any) => 
+        i.getModuleSpecifierValue() === moduleSpecifier
+    );
+    if (importDec) {
+        importDec.remove();
+    }
+};
+
+export const removeInterfaceProperty = (sourceFile: any, interfaceName: string, propertyName: string) => {
+    // 1. Try finding top-level interface
+    let intf = sourceFile.getInterface(interfaceName);
+
+    // 2. If not found, try finding inside modules (declare module '...')
+    if (!intf) {
+        const modules = sourceFile.getModules();
+        for (const module of modules) {
+            intf = module.getInterface(interfaceName);
+            if (intf) break;
+        }
+    }
+
+    if (intf) {
+        // Check if property is nested (e.g. 'resources.p_org')
+        // This is a bit complex if we want generic nested support.
+        // For the specific case of i18next resources, the interface property 'resources' is an object type literal.
+        // The user wants to remove properties FROM that object type literal.
+        
+        // Strategy:
+        // If interface has property 'resources', and we want to remove 'p_org' FROM 'resources'...
+        // The current usage in organization/index.ts is: removeInterfaceProperty(sourceFile, 'resources', 'p_org');
+        // This implies the function expects 'resources' to be the interface name? NO. 
+        // In i18next.d.ts: interface CustomTypeOptions { resources: { ... } }
+        
+        // Wait, the usage in organization/index.ts is:
+        // removeInterfaceProperty(sourceFile, 'resources', 'p_org');
+        // valid interface name is 'CustomTypeOptions'. 
+        // 'resources' is a PROPERTY of 'CustomTypeOptions', which has a type literal value.
+        
+        // So I should fix the usage in organization/index.ts OR update this helper to handle this specific structure.
+        // Given the helper signature (interfaceName, propertyName), passing 'resources' as interfaceName is WRONG effectively.
+        // But wait, maybe I can make this helper smarter or create a new one.
+
+        // Let's implement a 'removePropertyFromInterfaceProperty' helper? 
+        // Or update this one to strict usage.
+        
+        // Let's stick to the current plan: Update `ast.ts` to generally support finding interfaces in modules.
+        // AND add a new helper `removeNestedInterfaceProperty`?
+        
+        // Actually, looking at `i18next.d.ts`, `resources` is a property of `CustomTypeOptions`.
+        // The value of `resources` is `{ p_org: ... }`.
+        
+        const prop = intf.getProperty(propertyName);
+        if (prop) {
+            prop.remove();
+        }
+    }
+};
+
+export const removePropertyFromInterfaceType = (sourceFile: any, interfaceName: string, parentPropertyName: string, childPropertyName: string) => {
+     // 1. Try finding top-level interface
+    let intf = sourceFile.getInterface(interfaceName);
+
+    // 2. If not found, try finding inside modules (declare module '...')
+    if (!intf) {
+        const modules = sourceFile.getModules();
+        for (const module of modules) {
+            intf = module.getInterface(interfaceName);
+            if (intf) break;
+        }
+    }
+
+    if (intf) {
+        const parentProp = intf.getProperty(parentPropertyName);
+        if (parentProp) {
+            // In ts-morph, getTypeNode() returns a TypeNode.
+            // We need to check if it's a TypeLiteralNode to use getMember.
+            const typeNode = parentProp.getTypeNode();
+            if (typeNode && typeNode.getKind() === SyntaxKind.TypeLiteral) {
+                 const typeLiteral = typeNode.asKind(SyntaxKind.TypeLiteral);
+                 if (typeLiteral) {
+                     // Get all properties and check names to handle quotes (e.g. 'p_org-settings')
+                     const properties = typeLiteral.getProperties();
+                     for (const prop of properties) {
+                         // prop.getName() usually returns the name without quotes if possible, or with?
+                         // Let's check both or normalize.
+                         const name = prop.getName();
+                         // Remove quotes from name if present for comparison
+                         const normalizedName = name.replace(/['"]/g, '');
+                         const normalizedTarget = childPropertyName.replace(/['"]/g, '');
+                         
+                         if (normalizedName === normalizedTarget) {
+                             prop.remove();
+                             // Don't break if we want to remove multiple? 
+                             // But here we target one property.
+                             // However, if we mutate the array while iterating... 
+                             // ts-morph handles removal safely usually, but let's break to be safe as we found the match.
+                             break;
+                         }
+                     }
+                 }
+            }
+        }
+    }
+}
+
+export const removeHookCall = (sourceFile: any, hookName: string) => {
+    const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const call of callExpressions) {
+        const expression = call.getExpression();
+        if (expression.getText() === hookName) {
+            // Check if it's a standalone statement (ExpressionStatement)
+            const stmt = call.getParentIfKind(SyntaxKind.ExpressionStatement);
+            if (stmt) {
+                stmt.remove();
+            }
+        }
+    }
+};
+
+export const removeObjectFromArray = (sourceFile: any, variableName: string, propertyKey: string, propertyValueIdentifier: string) => {
+    const variable = sourceFile.getVariableDeclaration(variableName);
+    if (variable) {
+        const initializer = variable.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
+        if (initializer) {
+            const elements = initializer.getElements();
+            for (const element of elements) {
+                if (element.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                    const obj = element;
+                    const prop = obj.getProperty(propertyKey);
+                    
+                    if (prop && prop.getKind() === SyntaxKind.PropertyAssignment) {
+                        const assignment = prop;
+                        // Check if the initializer text matches our target (e.g. 'organizationProxy')
+                        if (assignment.getInitializer()?.getText() === propertyValueIdentifier) {
+                            initializer.removeElement(element);
+                            break; 
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+
+// ... existing exports ...
+
+export const unwrapDefaultExport = (sourceFile: any, wrapperName: string) => {
+    const exportAssignments = sourceFile.getExportAssignments();
+    const defaultExport = exportAssignments.find((e: any) => !e.isExportEquals());
+
+    if (defaultExport) {
+        const expression = defaultExport.getExpression();
+        
+        if (expression.getKind() === SyntaxKind.CallExpression) {
+            const callExpr = expression;
+            // Need to cast or assume it has getExpression
+            const exprName = callExpr.getExpression().getText();
+
+            if (exprName === wrapperName) {
+                const args = callExpr.getArguments();
+                
+                if (args.length > 0) {
+                    const firstArg = args[0];
+                    defaultExport.setExpression(firstArg.getText());
+                }
+            }
+        }
+    }
+};
+
+export const removeI18nNamespace = (sourceFile: any, namespacePrefix: string) => {
+    // 1. Remove properties from resources interface
+    // Try finding top-level interface
+    let intf = sourceFile.getInterface('CustomTypeOptions');
+    if (!intf) {
+        const modules = sourceFile.getModules();
+        for (const module of modules) {
+            intf = module.getInterface('CustomTypeOptions');
+            if (intf) break;
+        }
+    }
+
+    if (intf) {
+        const resourcesProp = intf.getProperty('resources');
+        if (resourcesProp) {
+            const typeNode = resourcesProp.getTypeNode();
+            if (typeNode && typeNode.getKind() === SyntaxKind.TypeLiteral) {
+                 const typeLiteral = typeNode.asKind(SyntaxKind.TypeLiteral);
+                 if (typeLiteral) {
+                     const properties = typeLiteral.getProperties();
+                     for (const prop of properties) {
+                         const name = prop.getName();
+                         const normalizedName = name.replace(/['"]/g, '');
+                         
+                         // Check if name matches prefix (e.g. 'p_org' matches prefix 'p_org')
+                     if (normalizedName === namespacePrefix || normalizedName.startsWith(`${namespacePrefix}-`)) {
+                             prop.remove();
+                         }
+                     }
+                 }
+            }
+        }
+    }
+
+    // 2. Remove imports that import files starting with the prefix in the locales folder
+    // This assumes a specific structure: .../locales/en/${prefix}*.json
+    // Or just check if the import module specifier contains the prefix in the filename part?
+    // Let's be a bit specific to avoid false positives.
+    // The user's files are like `../../../kit/organization/src/i18n/locales/en/p_org.json`
+    
+    // Strategy: iterate imports, get module specifier.
+    // If it ends with `/${namespacePrefix}.json` or `/${namespacePrefix}-*.json`, remove it.
+    
+    const imports = sourceFile.getImportDeclarations();
+    for (const importDec of imports) {
+        const moduleSpecifier = importDec.getModuleSpecifierValue();
+        const baseName = path.basename(moduleSpecifier);
+        
+        if (baseName === `${namespacePrefix}.json` || baseName.startsWith(`${namespacePrefix}-`)) {
+            importDec.remove();
+        }
+    }
+};
+
+export const removeInternalPackages = (sourceFile: any, packagesToRemove: string[]) => {
+    const variableDeclaration = sourceFile.getVariableDeclaration('INTERNAL_PACKAGES');
+    if (variableDeclaration) {
+        const initializer = variableDeclaration.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
+        if (initializer) {
+            const elements = initializer.getElements();
+            for (const element of elements) {
+                const text = element.getText().replace(/['"]/g, '');
+                if (packagesToRemove.includes(text)) {
+                    initializer.removeElement(element);
+                }
+            }
+        }
+    }
+};
+
+export const removeInlineJSX = (sourceFile: any, jsxTagName: string) => {
+    // Determine which kind of JSX element we are looking for
+    // 1. Self closing: <TagName /> (JsxSelfClosingElement)
+    // 2. Opening/Closing: <TagName>...</TagName> (JsxElement)
+    
+    // Find all JSX elements
+    // We can search for both JsxSelfClosingElement and JsxElement
+    
+    const selfClosingElements = sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement);
+    
+    for (const element of selfClosingElements) {
+        const tagName = element.getTagNameNode().getText();
+        
+        if (tagName === jsxTagName) {
+            if (typeof element.remove === 'function') {
+                element.remove();
+            } else if (typeof element.replaceWithText === 'function') {
+                element.replaceWithText('');
+            }
+        }
+    }
+
+    const jsxElements = sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement);
+    
+    for (const element of jsxElements) {
+        if (element.getOpeningElement().getTagNameNode().getText() === jsxTagName) {
+             if (typeof element.remove === 'function') {
+                element.remove();
+            } else if (typeof element.replaceWithText === 'function') {
+                element.replaceWithText('');
+            }
+        }
+    }
+};
+
+export const removePropertyAssignment = (sourceFile: any, propertyName: string) => {
+    // Find all property assignments with the matching name
+    const assignments = sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment);
+    for (const assignment of assignments) {
+        if (assignment.getName() === propertyName) {
+            if (typeof assignment.remove === 'function') {
+                assignment.remove();
+            } else if (typeof assignment.replaceWithText === 'function') {
+                assignment.replaceWithText('');
+            }
+        }
+    }
+    
+    // Also handle ShorthandPropertyAssignment (e.g. { keybindingsModel })
+    const shorthands = sourceFile.getDescendantsOfKind(SyntaxKind.ShorthandPropertyAssignment);
+    for (const shorthand of shorthands) {
+        if (shorthand.getName() === propertyName) {
+            if (typeof shorthand.remove === 'function') {
+                shorthand.remove();
+            } else if (typeof shorthand.replaceWithText === 'function') {
+                shorthand.replaceWithText('');
+            }
+        }
+    }
+};
+
+const getRootIdentifierText = (expression: any): string | null => {
+    if (!expression) return null;
+
+    if (expression.getKind() === SyntaxKind.Identifier) {
+        return expression.getText();
+    }
+
+    if (expression.getKind() === SyntaxKind.CallExpression) {
+        return getRootIdentifierText(expression.getExpression());
+    }
+
+    if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+        return getRootIdentifierText(expression.getExpression());
+    }
+
+    if (expression.getKind() === SyntaxKind.ElementAccessExpression) {
+        return getRootIdentifierText(expression.getExpression());
+    }
+
+    if (expression.getKind() === SyntaxKind.ParenthesizedExpression) {
+        return getRootIdentifierText(expression.getExpression());
+    }
+
+    return null;
+};
+
+export const removeEnvExtendsByModuleSpecifiers = (sourceFile: any, moduleSpecifiers: string[]) => {
+    if (!moduleSpecifiers || moduleSpecifiers.length === 0) return;
+
+    const moduleSet = new Set(moduleSpecifiers);
+    const identifiersToRemove = new Set<string>();
+
+    const matchesAnySpecifier = (importPath: string): boolean => {
+        if (moduleSet.has(importPath)) return true;
+        for (const spec of moduleSet) {
+            if (importPath.startsWith(spec + '/')) return true;
+        }
+        return false;
+    };
+
+    const imports = sourceFile.getImportDeclarations();
+    for (const importDec of imports) {
+        const moduleSpecifier = importDec.getModuleSpecifierValue();
+        if (!matchesAnySpecifier(moduleSpecifier)) continue;
+
+        const defaultImport = importDec.getDefaultImport();
+        if (defaultImport) {
+            identifiersToRemove.add(defaultImport.getText());
+        }
+
+        const namespaceImport = importDec.getNamespaceImport();
+        if (namespaceImport) {
+            identifiersToRemove.add(namespaceImport.getText());
+        }
+
+        for (const namedImport of importDec.getNamedImports()) {
+            identifiersToRemove.add(namedImport.getNameNode().getText());
+        }
+
+        importDec.remove();
+    }
+
+    if (identifiersToRemove.size === 0) return;
+
+    const properties = sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment);
+    for (const property of properties) {
+        if (property.getName() !== 'extends') continue;
+
+        const initializer = property.getInitializerIfKind(SyntaxKind.ArrayLiteralExpression);
+        if (!initializer) continue;
+
+        const elements = initializer.getElements();
+        for (let i = elements.length - 1; i >= 0; i--) {
+            const element = elements[i];
+            const rootIdentifier = getRootIdentifierText(element);
+            if (rootIdentifier && identifiersToRemove.has(rootIdentifier)) {
+                initializer.removeElement(i);
+            }
+        }
+    }
+};
+
+/**
+ * Removes a SpreadAssignment from a named object literal (const or export const).
+ * Matches `...routerName` or `...routerName(...)` (call expression spread).
+ *
+ * @param sourceFile  ts-morph SourceFile
+ * @param objectName  Name of the variable whose initializer contains the spread (e.g. 'appRouter' body)
+ * @param routerName  Root identifier to match (e.g. 'aiRouter', 'getKeybindingsRouter')
+ */
+export const removeSpreadFromObject = (sourceFile: any, objectName: string, routerName: string) => {
+    const spreads = sourceFile.getDescendantsOfKind(SyntaxKind.SpreadAssignment);
+    for (const spread of spreads) {
+        const expr = spread.getExpression();
+        // Resolve root identifier: handles both `...aiRouter` and `...getKeybindingsRouter(args)`
+        let rootName: string;
+        if (expr.getKind() === SyntaxKind.CallExpression) {
+            rootName = (expr as any).getExpression().getText();
+        } else {
+            rootName = expr.getText();
+        }
+        if (rootName === routerName) {
+            spread.remove();
+        }
+    }
+};