@cleosync/cosmos-cli 0.1.0

package/README.md

@@ -0,0 +1,42 @@
+# @cleosync/cosmos-cli
+
+Config-driven project initialization for Cosmos UI.
+
+## Install
+
+```sh
+npm install -g @cleosync/cosmos-cli
+```
+
+## Usage
+
+Create `cosmos.config.ts` in your app, then run:
+
+```sh
+cosmos init
+```
+
+The CLI reads enabled modules from config:
+
+```ts
+export default defineConfig({
+  modules: {
+    api: { baseUrl: process.env.EXPO_PUBLIC_API_URL },
+    query: true,
+    auth: { provider: 'custom', nin: true },
+    errors: true,
+    push: { provider: 'expo' },
+  },
+});
+```
+
+`cosmos init` installs required peer packages and writes project-specific scaffolds. It does not copy design-system components into your app.
+
+## Options
+
+```sh
+cosmos init --config cosmos.config.ts
+cosmos init --package @cleosync/cosmos-ui
+cosmos init --skip-install
+cosmos init --dry-run
+```

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+interface InitOptions {
+    config: string;
+    package: string;
+    skipInstall?: boolean;
+    dryRun?: boolean;
+}
+export declare function initCommand(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,371 @@
+import path from 'node:path';
+import pc from 'picocolors';
+import { pathExists, readText, resolveFromCwd, writeFileIfMissing } from '../utils/fs.js';
+import { installExpoPackages, installNpmPackages } from '../utils/installer.js';
+import { logger } from '../utils/logger.js';
+const moduleOrder = ['api', 'query', 'auth', 'errors', 'push'];
+const npmPackages = {
+    api: ['axios'],
+    auth: ['zustand'],
+    errors: [],
+    push: [],
+    query: ['@tanstack/react-query'],
+};
+const expoPackages = {
+    api: [],
+    auth: ['expo-secure-store'],
+    errors: [],
+    push: ['expo-notifications', 'expo-device', 'expo-constants'],
+    query: [],
+};
+export async function initCommand(options) {
+    const configPath = resolveFromCwd(options.config);
+    if (!(await pathExists(configPath))) {
+        logger.error(`Could not find ${options.config}. Create it first, then run ${pc.bold('cosmos init')}.`);
+        process.exitCode = 1;
+        return;
+    }
+    const configSource = await readText(configPath);
+    const modules = getEnabledModules(configSource);
+    logger.title('Cosmos init');
+    logger.info(`${pc.gray('config')} ${path.relative(process.cwd(), configPath)}`);
+    logger.info(`${pc.gray('modules')} ${modules.length ? modules.join(', ') : 'none'}`);
+    if (modules.length === 0) {
+        logger.warn('No modules declared. Nothing to scaffold.');
+        return;
+    }
+    const npmDeps = unique(modules.flatMap((moduleName) => npmPackages[moduleName]));
+    const expoDeps = unique(modules.flatMap((moduleName) => expoPackages[moduleName]));
+    if (!options.skipInstall && !options.dryRun) {
+        if (npmDeps.length) {
+            logger.info(`${pc.gray('npm install')} ${npmDeps.join(' ')}`);
+            await installNpmPackages(npmDeps);
+        }
+        if (expoDeps.length) {
+            logger.info(`${pc.gray('npx expo install')} ${expoDeps.join(' ')}`);
+            await installExpoPackages(expoDeps);
+        }
+    }
+    else if (npmDeps.length || expoDeps.length) {
+        logger.dim(`install skipped: ${[...npmDeps, ...expoDeps].join(', ')}`);
+    }
+    const files = getScaffoldFiles(modules, options.package);
+    for (const file of files) {
+        const destination = resolveFromCwd(file.path);
+        if (options.dryRun) {
+            logger.info(`${pc.gray('[dry-run]')} write ${file.path}`);
+            continue;
+        }
+        const written = await writeFileIfMissing(destination, file.contents);
+        logger.info(`${written ? pc.green('[created]') : pc.yellow('[exists]')} ${file.path}`);
+    }
+    logger.success('Cosmos init complete.');
+}
+function getEnabledModules(configSource) {
+    const modulesBlock = getObjectOrArrayBlock(configSource, 'modules');
+    if (!modulesBlock) {
+        return [];
+    }
+    return moduleOrder.filter((moduleName) => isModuleEnabled(modulesBlock, moduleName));
+}
+function isModuleEnabled(modulesBlock, moduleName) {
+    const arrayPattern = new RegExp(`['"\`]${moduleName}['"\`]`);
+    const objectPattern = new RegExp(`\\b${moduleName}\\s*:\\s*(?!false\\b|undefined\\b|null\\b)`);
+    return arrayPattern.test(modulesBlock) || objectPattern.test(modulesBlock);
+}
+function getObjectOrArrayBlock(source, propertyName) {
+    const propertyIndex = source.search(new RegExp(`\\b${propertyName}\\s*:`));
+    if (propertyIndex < 0) {
+        return null;
+    }
+    const openerIndex = source.slice(propertyIndex).search(/[{\[]/);
+    if (openerIndex < 0) {
+        return null;
+    }
+    const blockStart = propertyIndex + openerIndex;
+    const opener = source[blockStart];
+    const closer = opener === '[' ? ']' : '}';
+    let depth = 0;
+    for (let index = blockStart; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === opener)
+            depth += 1;
+        if (char === closer)
+            depth -= 1;
+        if (depth === 0) {
+            return source.slice(blockStart, index + 1);
+        }
+    }
+    return null;
+}
+function getScaffoldFiles(modules, packageName) {
+    const files = [];
+    const has = (moduleName) => modules.includes(moduleName);
+    if (has('api')) {
+        files.push(file('lib/api/client.ts', apiClientTemplate(packageName)), file('lib/api/index.ts', "export { api } from './client';\n"));
+    }
+    if (has('query')) {
+        files.push(file('lib/query/client.ts', queryClientTemplate(packageName)), file('lib/query/provider.tsx', queryProviderTemplate(packageName)), file('lib/query/index.ts', "export { queryClient } from './client';\nexport { QueryProvider } from './provider';\n"));
+    }
+    if (has('auth')) {
+        files.push(file('features/auth/types.ts', authTypesTemplate()), file('features/auth/api/index.ts', authKeysTemplate()), file('features/auth/api/auth.api.ts', authApiTemplate(packageName)), file('features/auth/hooks/use-auth.queries.ts', authQueriesTemplate(packageName)), file('features/auth/hooks/use-auth.mutations.ts', authMutationsTemplate(packageName)), file('features/auth/index.ts', authIndexTemplate(packageName)));
+    }
+    if (has('errors')) {
+        files.push(file('lib/errors/index.ts', errorsIndexTemplate(packageName)), file('lib/errors/fallback.tsx', errorsFallbackTemplate(packageName)));
+    }
+    if (has('push')) {
+        files.push(file('features/notifications/types.ts', notificationsTypesTemplate(packageName)), file('features/notifications/hooks/use-notifications.queries.ts', notificationQueriesTemplate(packageName)), file('features/notifications/hooks/use-notifications.mutations.ts', notificationMutationsTemplate(packageName)), file('features/notifications/index.ts', notificationsIndexTemplate(packageName)));
+    }
+    files.push(file('app/_layout.cosmos.example.tsx', layoutExampleTemplate(packageName, modules)));
+    return files;
+}
+function file(filePath, contents) {
+    return { path: filePath, contents };
+}
+function unique(values) {
+    return Array.from(new Set(values)).filter(Boolean);
+}
+function apiClientTemplate(packageName) {
+    return `import axios from 'axios';
+import { normalizeApiError } from '${packageName}';
+
+export const api = axios.create({
+  baseURL: process.env.EXPO_PUBLIC_API_URL,
+  headers: { 'Content-Type': 'application/json' },
+  timeout: 15000,
+});
+
+api.interceptors.request.use((config) => {
+  // TODO: inject auth token when your auth module is wired.
+  return config;
+});
+
+api.interceptors.response.use(
+  (response) => response,
+  (error) => Promise.reject(normalizeApiError(error)),
+);
+`;
+}
+function queryClientTemplate(packageName) {
+    return `import { createCosmosQueryClient } from '${packageName}';
+
+export const queryClient = createCosmosQueryClient();
+`;
+}
+function queryProviderTemplate(packageName) {
+    return `export { QueryProvider } from '${packageName}';
+export type { QueryProviderProps } from '${packageName}';
+`;
+}
+function authTypesTemplate() {
+    return `export interface User {
+  id: string;
+  email: string;
+  name?: string;
+}
+
+export interface LoginPayload {
+  email: string;
+  password: string;
+}
+
+export interface RegisterPayload {
+  name: string;
+  email: string;
+  password: string;
+}
+`;
+}
+function authKeysTemplate() {
+    return `export const authKeys = {
+  all: ['auth'] as const,
+  session: () => [...authKeys.all, 'session'] as const,
+  profile: (userId: string) => [...authKeys.all, 'profile', userId] as const,
+};
+`;
+}
+function authApiTemplate(packageName) {
+    return `import { api } from '../../../lib/api';
+import type { AuthTokens } from '${packageName}';
+import type { LoginPayload, RegisterPayload, User } from '../types';
+
+export async function login(payload: LoginPayload): Promise<{ user: User; tokens: AuthTokens }> {
+  const { data } = await api.post('/auth/login', payload);
+  return data;
+}
+
+export async function register(payload: RegisterPayload): Promise<{ user: User; tokens: AuthTokens }> {
+  const { data } = await api.post('/auth/register', payload);
+  return data;
+}
+
+export async function getSession(): Promise<User> {
+  const { data } = await api.get('/auth/session');
+  return data;
+}
+
+export async function logout(): Promise<void> {
+  await api.post('/auth/logout');
+}
+`;
+}
+function authQueriesTemplate(packageName) {
+    return `import { useQuery } from '@tanstack/react-query';
+import { useAuthStore } from '${packageName}';
+import { authKeys } from '../api';
+import { getSession } from '../api/auth.api';
+
+export function useSessionQuery() {
+  const isAuthenticated = useAuthStore((state) => state.isAuthenticated);
+
+  return useQuery({
+    enabled: isAuthenticated,
+    queryKey: authKeys.session(),
+    queryFn: async () => {
+      const user = await getSession();
+      useAuthStore.getState().setUser(user);
+      return user;
+    },
+  });
+}
+`;
+}
+function authMutationsTemplate(packageName) {
+    return `import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { toast, useAuthStore } from '${packageName}';
+import { authKeys } from '../api';
+import { login, logout, register } from '../api/auth.api';
+
+export function useLoginMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: login,
+    onSuccess: async ({ tokens, user }) => {
+      useAuthStore.getState().setTokens(tokens);
+      useAuthStore.getState().setUser(user);
+      await queryClient.invalidateQueries({ queryKey: authKeys.session() });
+    },
+    onError: () => {
+      toast.error('Unable to log in', { description: 'Check your details and try again.' });
+    },
+  });
+}
+
+export function useRegisterMutation() {
+  return useMutation({
+    mutationFn: register,
+    onError: () => {
+      toast.error('Unable to create account', { description: 'Please review the form and try again.' });
+    },
+  });
+}
+
+export function useLogoutMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: logout,
+    onSettled: () => {
+      useAuthStore.getState().clearAuth();
+      queryClient.clear();
+    },
+  });
+}
+`;
+}
+function authIndexTemplate(packageName) {
+    return `export { AuthGuard, ProtectedRoute, useAuthStore } from '${packageName}';
+export * from './api/auth.api';
+export * from './hooks/use-auth.queries';
+export * from './hooks/use-auth.mutations';
+export * from './types';
+`;
+}
+function errorsIndexTemplate(packageName) {
+    return `export {
+  AppError,
+  CosmosErrorFallback,
+  ErrorBoundary,
+  globalErrorHandler,
+  NetworkError,
+  ValidationError,
+} from '${packageName}';
+`;
+}
+function errorsFallbackTemplate(packageName) {
+    return `import { CosmosErrorFallback as BaseCosmosErrorFallback } from '${packageName}';
+
+export function CosmosErrorFallback(props: { error?: Error; reset: () => void }) {
+  return <BaseCosmosErrorFallback {...props} />;
+}
+`;
+}
+function notificationsTypesTemplate(packageName) {
+    return `export type { NotificationData, NotificationHandler, PushToken } from '${packageName}';
+`;
+}
+function notificationQueriesTemplate(packageName) {
+    return `import { useQuery } from '@tanstack/react-query';
+import { getPushPermissionStatus } from '${packageName}';
+
+export function usePushPermissionQuery() {
+  return useQuery({
+    queryKey: ['notifications', 'permission'],
+    queryFn: getPushPermissionStatus,
+  });
+}
+`;
+}
+function notificationMutationsTemplate(packageName) {
+    return `import { useMutation } from '@tanstack/react-query';
+import { registerForPushNotificationsAsync, sendLocalNotification } from '${packageName}';
+
+export function useRegisterPushTokenMutation() {
+  return useMutation({
+    mutationFn: async () => {
+      const token = await registerForPushNotificationsAsync();
+      // TODO: send token to your backend.
+      return { token };
+    },
+  });
+}
+
+export function useSendLocalNotificationMutation() {
+  return useMutation({
+    mutationFn: ({ title, body }: { title: string; body: string }) =>
+      sendLocalNotification(title, body),
+  });
+}
+`;
+}
+function notificationsIndexTemplate(packageName) {
+    return `export {
+  getPushPermissionStatus,
+  registerForPushNotificationsAsync,
+  sendLocalNotification,
+} from '${packageName}';
+export * from './hooks/use-notifications.queries';
+export * from './hooks/use-notifications.mutations';
+export * from './types';
+`;
+}
+function layoutExampleTemplate(packageName, modules) {
+    const hasQuery = modules.includes('query');
+    const hasErrors = modules.includes('errors');
+    return `import { CosmosProvider${hasErrors ? ', ErrorBoundary, CosmosErrorFallback' : ''} } from '${packageName}';
+${hasQuery ? "import { QueryProvider } from '../lib/query';\n" : ''}import config from '../cosmos.config';
+
+export default function RootLayout() {
+  const app = (
+    <CosmosProvider config={config}>
+      {/* TODO: render your router stack here */}
+    </CosmosProvider>
+  );
+
+  const withQuery = ${hasQuery ? '<QueryProvider>{app}</QueryProvider>' : 'app'};
+
+  return ${hasErrors ? '<ErrorBoundary fallback={(props) => <CosmosErrorFallback {...props} />}>{withQuery}</ErrorBoundary>' : 'withQuery'};
+}
+`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+const program = new Command();
+program.name('cosmos').description('Cosmos UI project setup CLI').version('0.1.0');
+program
+    .command('init')
+    .description('Initialize Cosmos UI from cosmos.config.ts')
+    .option('--config <path>', 'path to cosmos config', 'cosmos.config.ts')
+    .option('--package <name>', 'Cosmos UI package import name', '@cleosync/cosmos-ui')
+    .option('--skip-install', 'write scaffold files without installing peer packages')
+    .option('--dry-run', 'print what would happen without writing files or installing packages')
+    .action(initCommand);
+await program.parseAsync(process.argv);

package/dist/utils/fs.d.ts

@@ -0,0 +1,6 @@
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function copyTemplate(source: string, destination: string): Promise<void>;
+export declare function readText(filePath: string): Promise<string>;
+export declare function writeFileIfMissing(filePath: string, contents: string): Promise<boolean>;
+export declare function interpolateTemplate(template: string, values: Record<string, string>): string;
+export declare function resolveFromCwd(...segments: string[]): string;

package/dist/utils/fs.js

@@ -0,0 +1,26 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+export async function pathExists(filePath) {
+    return fs.pathExists(filePath);
+}
+export async function copyTemplate(source, destination) {
+    await fs.ensureDir(path.dirname(destination));
+    await fs.copy(source, destination, { overwrite: false });
+}
+export async function readText(filePath) {
+    return fs.readFile(filePath, 'utf8');
+}
+export async function writeFileIfMissing(filePath, contents) {
+    if (await fs.pathExists(filePath)) {
+        return false;
+    }
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, contents);
+    return true;
+}
+export function interpolateTemplate(template, values) {
+    return Object.entries(values).reduce((output, [key, value]) => output.replaceAll(`{{${key}}}`, value), template);
+}
+export function resolveFromCwd(...segments) {
+    return path.resolve(process.cwd(), ...segments);
+}

package/dist/utils/installer.d.ts

@@ -0,0 +1,3 @@
+export declare function runCommand(command: string, args: string[], cwd?: string): Promise<void>;
+export declare function installNpmPackages(packages: string[], cwd?: string): Promise<void>;
+export declare function installExpoPackages(packages: string[], cwd?: string): Promise<void>;

package/dist/utils/installer.js

@@ -0,0 +1,29 @@
+import { spawn } from 'node:child_process';
+export function runCommand(command, args, cwd = process.cwd()) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            shell: true,
+            stdio: 'inherit',
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${command} ${args.join(' ')} exited with code ${code}`));
+        });
+    });
+}
+export function installNpmPackages(packages, cwd = process.cwd()) {
+    if (packages.length === 0) {
+        return Promise.resolve();
+    }
+    return runCommand('npm', ['install', ...packages], cwd);
+}
+export function installExpoPackages(packages, cwd = process.cwd()) {
+    if (packages.length === 0) {
+        return Promise.resolve();
+    }
+    return runCommand('npx', ['expo', 'install', ...packages], cwd);
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,9 @@
+export declare const logger: {
+    dim: (message: string) => void;
+    error: (message: string) => void;
+    info: (message: string) => void;
+    success: (message: string) => void;
+    title: (message: string) => void;
+    warn: (message: string) => void;
+};
+export declare function formatStatus(installed: boolean, planned: boolean): string;

package/dist/utils/logger.js

@@ -0,0 +1,18 @@
+import pc from 'picocolors';
+export const logger = {
+    dim: (message) => console.log(pc.gray(message)),
+    error: (message) => console.error(pc.red(message)),
+    info: (message) => console.log(message),
+    success: (message) => console.log(pc.green(message)),
+    title: (message) => console.log(pc.bold(message)),
+    warn: (message) => console.log(pc.yellow(message)),
+};
+export function formatStatus(installed, planned) {
+    if (installed) {
+        return pc.green('installed');
+    }
+    if (planned) {
+        return pc.gray('planned');
+    }
+    return pc.white('available');
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@cleosync/cosmos-cli",
+  "version": "0.1.0",
+  "description": "Config-driven Cosmos UI project initialization CLI.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "cosmos": "dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "init": "node dist/index.js init",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "keywords": [
+    "cosmos",
+    "cleosync",
+    "react-native",
+    "expo",
+    "cli"
+  ],
+  "author": "Cleosync",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.5",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.6.2",
+    "typescript": "^5.9.3"
+  }
+}