morphkit-cli 0.1.0

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "morphkit-cli",
+  "version": "0.1.0",
+  "description": "Semantic AI agent that converts TypeScript/React web apps to native SwiftUI iOS apps",
+  "type": "module",
+  "bin": {
+    "morphkit": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "analyze": "bun run src/index.ts analyze",
+    "generate": "bun run src/index.ts generate",
+    "prepublishOnly": "bun build src/index.ts --outdir dist --target node --minify"
+  },
+  "dependencies": {
+    "openai": "^4.0.0",
+    "ts-morph": "^24.0.0",
+    "commander": "^13.0.0",
+    "chalk": "^5.4.0",
+    "ora": "^8.0.0",
+    "simple-git": "^3.27.0",
+    "fast-glob": "^3.3.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "typescript",
+    "swift",
+    "swiftui",
+    "ios",
+    "react",
+    "nextjs",
+    "code-generation",
+    "ai",
+    "mobile"
+  ],
+  "license": "MIT",
+  "author": "AshlrAI <hello@ashlr.ai>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ashlrai/morphkit.git"
+  },
+  "homepage": "https://morphkit.dev",
+  "bugs": "https://github.com/ashlrai/morphkit/issues",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/swift/app-entry.swift.ts

@@ -0,0 +1,46 @@
+// Template for generating the main App entry point
+
+export function generateAppEntry(appName: string): string {
+  return `// Generated by Morphkit
+import SwiftUI
+
+@main
+struct ${appName}App: App {
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+        }
+    }
+}
+`;
+}
+
+export function generateAppEntryWithState(appName: string, storeNames: string[]): string {
+  const storeDeclarations = storeNames
+    .map(name => `    @State private var ${camelCase(name)} = ${name}()`)
+    .join('\n');
+
+  const environmentModifiers = storeNames
+    .map(name => `                .environment(${camelCase(name)})`)
+    .join('\n');
+
+  return `// Generated by Morphkit
+import SwiftUI
+
+@main
+struct ${appName}App: App {
+${storeDeclarations}
+
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+${environmentModifiers}
+        }
+    }
+}
+`;
+}
+
+function camelCase(str: string): string {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}

package/templates/swift/model.swift.ts

@@ -0,0 +1,72 @@
+// Template for generating Swift data models
+
+export interface SwiftProperty {
+  name: string;
+  type: string;
+  optional: boolean;
+  defaultValue?: string;
+}
+
+export interface SwiftModelConfig {
+  name: string;
+  properties: SwiftProperty[];
+  protocols: string[];
+  hasId: boolean;
+  sourceFile: string;
+}
+
+export function generateSwiftModel(config: SwiftModelConfig): string {
+  const protocols = config.protocols.length > 0
+    ? `: ${config.protocols.join(', ')}`
+    : '';
+
+  const properties = config.properties
+    .map(p => {
+      const type = p.optional ? `${p.type}?` : p.type;
+      const defaultVal = p.defaultValue ? ` = ${p.defaultValue}` : '';
+      return `    var ${p.name}: ${type}${defaultVal}`;
+    })
+    .join('\n');
+
+  // Generate CodingKeys if any property names need mapping
+  const needsCodingKeys = config.properties.some(p => p.name.includes('_') || p.name !== camelCase(p.name));
+  const codingKeys = needsCodingKeys
+    ? generateCodingKeys(config.properties)
+    : '';
+
+  return `// Generated by Morphkit from: ${config.sourceFile}
+import Foundation
+
+struct ${config.name}${protocols} {
+${properties}
+}
+${codingKeys}`;
+}
+
+export function generateSwiftEnum(name: string, cases: string[], sourceFile: string): string {
+  const enumCases = cases.map(c => `    case ${camelCase(c)}`).join('\n');
+
+  return `// Generated by Morphkit from: ${sourceFile}
+import Foundation
+
+enum ${name}: String, Codable, CaseIterable {
+${enumCases}
+}
+`;
+}
+
+function generateCodingKeys(properties: SwiftProperty[]): string {
+  const keys = properties
+    .map(p => `        case ${camelCase(p.name)} = "${p.name}"`)
+    .join('\n');
+
+  return `
+    enum CodingKeys: String, CodingKey {
+${keys}
+    }
+`;
+}
+
+function camelCase(str: string): string {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}

package/templates/swiftui/navigation.swift.ts

@@ -0,0 +1,118 @@
+// Templates for generating navigation structure
+
+export interface RouteDefinition {
+  name: string;
+  associatedValues?: { name: string; type: string }[];
+}
+
+export function generateRouterEnum(routes: RouteDefinition[]): string {
+  const cases = routes.map(r => {
+    if (r.associatedValues && r.associatedValues.length > 0) {
+      const values = r.associatedValues.map(v => `${v.name}: ${v.type}`).join(', ');
+      return `    case ${r.name}(${values})`;
+    }
+    return `    case ${r.name}`;
+  }).join('\n');
+
+  return `// Generated by Morphkit
+import SwiftUI
+
+enum AppRoute: Hashable {
+${cases}
+}
+`;
+}
+
+export function generateRouter(routes: RouteDefinition[]): string {
+  const destinationCases = routes.map(r => {
+    const viewName = pascalCase(r.name) + 'View';
+    if (r.associatedValues && r.associatedValues.length > 0) {
+      const bindings = r.associatedValues.map(v => `let ${v.name}`).join(', ');
+      const args = r.associatedValues.map(v => `${v.name}: ${v.name}`).join(', ');
+      return `            case .${r.name}(${bindings}):
+                ${viewName}(${args})`;
+    }
+    return `            case .${r.name}:
+                ${viewName}()`;
+  }).join('\n');
+
+  return `// Generated by Morphkit
+import SwiftUI
+
+@Observable
+final class Router {
+    var path = NavigationPath()
+
+    func navigate(to route: AppRoute) {
+        path.append(route)
+    }
+
+    func goBack() {
+        guard !path.isEmpty else { return }
+        path.removeLast()
+    }
+
+    func popToRoot() {
+        path = NavigationPath()
+    }
+}
+
+struct RouterDestination: ViewModifier {
+    func body(content: Content) -> some View {
+        content
+            .navigationDestination(for: AppRoute.self) { route in
+                switch route {
+${destinationCases}
+                }
+            }
+    }
+}
+
+extension View {
+    func withRouterDestinations() -> some View {
+        modifier(RouterDestination())
+    }
+}
+`;
+}
+
+export function generateNavigationStackRoot(rootView: string): string {
+  return `NavigationStack(path: $router.path) {
+    ${rootView}()
+        .withRouterDestinations()
+}`;
+}
+
+export function generateTabViewWithNavigation(
+  tabs: { name: string; icon: string; view: string }[],
+): string {
+  const tabContent = tabs.map(t => `            Tab("${t.name}", systemImage: "${t.icon}") {
+                NavigationStack {
+                    ${t.view}()
+                        .withRouterDestinations()
+                }
+            }`).join('\n');
+
+  return `// Generated by Morphkit
+import SwiftUI
+
+struct ContentView: View {
+    @State private var router = Router()
+
+    var body: some View {
+        TabView {
+${tabContent}
+        }
+        .environment(router)
+    }
+}
+
+#Preview {
+    ContentView()
+}
+`;
+}
+
+function pascalCase(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/templates/swiftui/networking.swift.ts

@@ -0,0 +1,145 @@
+// Templates for generating the networking layer
+
+export interface EndpointConfig {
+  name: string;
+  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+  path: string;
+  requestType?: string;
+  responseType: string;
+  requiresAuth: boolean;
+  description: string;
+}
+
+export function generateAPIClient(
+  baseURL: string,
+  endpoints: EndpointConfig[],
+  authStrategy: 'bearer' | 'cookie' | 'none',
+): string {
+  const endpointMethods = endpoints.map(generateEndpointMethod).join('\n\n');
+
+  const authHeader = authStrategy === 'bearer'
+    ? `
+    var authToken: String? {
+        get { UserDefaults.standard.string(forKey: "authToken") }
+        set { UserDefaults.standard.set(newValue, forKey: "authToken") }
+    }
+
+    private func authenticatedRequest(_ request: inout URLRequest) {
+        if let token = authToken {
+            request.setValue("Bearer \\(token)", forHTTPHeaderField: "Authorization")
+        }
+    }`
+    : '';
+
+  return `// Generated by Morphkit
+import Foundation
+
+@Observable
+final class APIClient {
+    static let shared = APIClient()
+
+    private let baseURL = URL(string: "${baseURL}")!
+    private let decoder: JSONDecoder = {
+        let decoder = JSONDecoder()
+        decoder.keyDecodingStrategy = .convertFromSnakeCase
+        decoder.dateDecodingStrategy = .iso8601
+        return decoder
+    }()
+    private let encoder: JSONEncoder = {
+        let encoder = JSONEncoder()
+        encoder.keyEncodingStrategy = .convertToSnakeCase
+        encoder.dateEncodingStrategy = .iso8601
+        return encoder
+    }()
+${authHeader}
+
+    private init() {}
+
+${endpointMethods}
+
+    // MARK: - Private Helpers
+
+    private func request<T: Decodable>(
+        method: String,
+        path: String,
+        body: (any Encodable)? = nil,
+        requiresAuth: Bool = false
+    ) async throws -> T {
+        let url = baseURL.appendingPathComponent(path)
+        var request = URLRequest(url: url)
+        request.httpMethod = method
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        if requiresAuth {
+            ${authStrategy === 'bearer' ? 'authenticatedRequest(&request)' : '// TODO: Add auth'}
+        }
+
+        if let body {
+            request.httpBody = try encoder.encode(body)
+        }
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw NetworkError.invalidResponse
+        }
+
+        guard (200...299).contains(httpResponse.statusCode) else {
+            throw NetworkError.httpError(statusCode: httpResponse.statusCode, data: data)
+        }
+
+        return try decoder.decode(T.self, from: data)
+    }
+}
+
+enum NetworkError: LocalizedError {
+    case invalidResponse
+    case httpError(statusCode: Int, data: Data)
+    case decodingError(Error)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidResponse:
+            return "Invalid response from server"
+        case .httpError(let statusCode, _):
+            return "HTTP error: \\(statusCode)"
+        case .decodingError(let error):
+            return "Failed to decode response: \\(error.localizedDescription)"
+        }
+    }
+}
+`;
+}
+
+function generateEndpointMethod(endpoint: EndpointConfig): string {
+  const params: string[] = [];
+  const pathWithInterpolation = endpoint.path.replace(/:(\w+)/g, (_, param) => {
+    params.push(`${param}: String`);
+    return `\\(${param})`;
+  });
+
+  if (endpoint.requestType && ['POST', 'PUT', 'PATCH'].includes(endpoint.method)) {
+    params.push(`body: ${endpoint.requestType}`);
+  }
+
+  const paramString = params.length > 0 ? params.join(', ') : '';
+  const bodyArg = endpoint.requestType && ['POST', 'PUT', 'PATCH'].includes(endpoint.method)
+    ? ', body: body'
+    : '';
+
+  const returnType = endpoint.responseType === 'Void' ? '' : ` -> ${endpoint.responseType}`;
+  const returnStatement = endpoint.responseType === 'Void'
+    ? `let _: EmptyResponse = try await request(method: "${endpoint.method}", path: "${pathWithInterpolation}"${bodyArg}, requiresAuth: ${endpoint.requiresAuth})`
+    : `return try await request(method: "${endpoint.method}", path: "${pathWithInterpolation}"${bodyArg}, requiresAuth: ${endpoint.requiresAuth})`;
+
+  return `    /// ${endpoint.description}
+    func ${endpoint.name}(${paramString}) async throws${returnType} {
+        ${returnStatement}
+    }`;
+}
+
+export function generateEmptyResponseType(): string {
+  return `
+struct EmptyResponse: Decodable {}
+`;
+}

package/templates/swiftui/view.swift.ts

@@ -0,0 +1,230 @@
+// Templates for generating SwiftUI views
+
+export interface ViewConfig {
+  name: string;
+  sourceFile: string;
+  stateProperties: StateProperty[];
+  bodyContent: string;
+  helperMethods: string[];
+  imports: string[];
+}
+
+export interface StateProperty {
+  wrapper: '@State' | '@Binding' | '@Environment' | '@Observable';
+  name: string;
+  type: string;
+  defaultValue?: string;
+}
+
+export function generateView(config: ViewConfig): string {
+  const imports = ['SwiftUI', ...config.imports]
+    .map(i => `import ${i}`)
+    .join('\n');
+
+  const stateProps = config.stateProperties
+    .map(p => {
+      if (p.wrapper === '@Environment') {
+        return `    @Environment(${p.type}.self) private var ${p.name}`;
+      }
+      const defaultVal = p.defaultValue ? ` = ${p.defaultValue}` : '';
+      return `    ${p.wrapper} private var ${p.name}: ${p.type}${defaultVal}`;
+    })
+    .join('\n');
+
+  const helpers = config.helperMethods.length > 0
+    ? '\n' + config.helperMethods.map(m => indentBlock(m, 4)).join('\n\n')
+    : '';
+
+  return `// Generated by Morphkit from: ${config.sourceFile}
+${imports}
+
+struct ${config.name}: View {
+${stateProps}
+
+    var body: some View {
+${indentBlock(config.bodyContent, 8)}
+    }${helpers}
+}
+
+#Preview {
+    ${config.name}()
+}
+`;
+}
+
+export function generateListView(
+  name: string,
+  sourceFile: string,
+  itemType: string,
+  rowContent: string,
+  stateProperties: StateProperty[],
+): string {
+  return generateView({
+    name,
+    sourceFile,
+    stateProperties: [
+      ...stateProperties,
+      { wrapper: '@State', name: 'items', type: `[${itemType}]`, defaultValue: '[]' },
+      { wrapper: '@State', name: 'isLoading', type: 'Bool', defaultValue: 'false' },
+    ],
+    bodyContent: `NavigationStack {
+    List(items) { item in
+        NavigationLink(value: item) {
+${indentBlock(rowContent, 12)}
+        }
+    }
+    .navigationTitle("${name}")
+    .overlay {
+        if isLoading {
+            ProgressView()
+        }
+    }
+    .task {
+        await loadItems()
+    }
+}`,
+    helperMethods: [
+      `private func loadItems() async {
+    isLoading = true
+    defer { isLoading = false }
+    // TODO: Load items from API
+}`,
+    ],
+    imports: [],
+  });
+}
+
+export function generateFormView(
+  name: string,
+  sourceFile: string,
+  fields: { name: string; type: string; label: string }[],
+): string {
+  const stateProperties: StateProperty[] = fields.map(f => ({
+    wrapper: '@State' as const,
+    name: f.name,
+    type: f.type,
+    defaultValue: getDefaultValue(f.type),
+  }));
+
+  const formFields = fields.map(f => {
+    switch (f.type) {
+      case 'String':
+        return `TextField("${f.label}", text: $${f.name})`;
+      case 'Bool':
+        return `Toggle("${f.label}", isOn: $${f.name})`;
+      case 'Date':
+        return `DatePicker("${f.label}", selection: $${f.name})`;
+      case 'Int':
+      case 'Double':
+        return `TextField("${f.label}", value: $${f.name}, format: .number)`;
+      default:
+        return `TextField("${f.label}", text: $${f.name})`;
+    }
+  }).join('\n');
+
+  return generateView({
+    name,
+    sourceFile,
+    stateProperties: [
+      ...stateProperties,
+      { wrapper: '@Environment', name: 'dismiss', type: '\\.dismiss' },
+    ],
+    bodyContent: `NavigationStack {
+    Form {
+        Section {
+${indentBlock(formFields, 12)}
+        }
+
+        Section {
+            Button("Save") {
+                save()
+            }
+            .frame(maxWidth: .infinity)
+        }
+    }
+    .navigationTitle("${name}")
+    .toolbar {
+        ToolbarItem(placement: .cancellationAction) {
+            Button("Cancel") { dismiss() }
+        }
+    }
+}`,
+    helperMethods: [
+      `private func save() {
+    // TODO: Implement save
+    dismiss()
+}`,
+    ],
+    imports: [],
+  });
+}
+
+export function generateDetailView(
+  name: string,
+  sourceFile: string,
+  modelType: string,
+  sections: { title: string; content: string }[],
+): string {
+  const sectionContent = sections
+    .map(s => `Section("${s.title}") {\n${indentBlock(s.content, 4)}\n}`)
+    .join('\n\n');
+
+  return generateView({
+    name,
+    sourceFile,
+    stateProperties: [],
+    bodyContent: `ScrollView {
+    VStack(alignment: .leading, spacing: 16) {
+${indentBlock(sectionContent, 8)}
+    }
+    .padding()
+}`,
+    helperMethods: [],
+    imports: [],
+  });
+}
+
+export function generateTabView(
+  tabs: { name: string; icon: string; view: string }[],
+): string {
+  const tabItems = tabs
+    .map(t => `            Tab("${t.name}", systemImage: "${t.icon}") {
+                ${t.view}()
+            }`)
+    .join('\n');
+
+  return `// Generated by Morphkit
+import SwiftUI
+
+struct ContentView: View {
+    var body: some View {
+        TabView {
+${tabItems}
+        }
+    }
+}
+
+#Preview {
+    ContentView()
+}
+`;
+}
+
+function getDefaultValue(type: string): string {
+  switch (type) {
+    case 'String': return '""';
+    case 'Bool': return 'false';
+    case 'Int': return '0';
+    case 'Double': return '0.0';
+    case 'Date': return '.now';
+    default: return '""';
+  }
+}
+
+function indentBlock(content: string, spaces: number): string {
+  const indent = ' '.repeat(spaces);
+  return content
+    .split('\n')
+    .map(line => line.length > 0 ? `${indent}${line}` : line)
+    .join('\n');
+}