@launch77/cli 1.2.0

package/src/modules/startup/types/startup-types.ts

@@ -0,0 +1,8 @@
+export interface CreateStartupRequest {
+  name: string
+}
+
+export interface CreateStartupResult {
+  startupPath: string
+  name: string
+}

package/src/modules/startup/utils/startup-validators.ts

@@ -0,0 +1,19 @@
+import { InvalidStartupNameError } from '../errors/startup-errors.js'
+
+/**
+ * Validate startup name format
+ * - Must be lowercase
+ * - Can only contain lowercase letters, numbers, and hyphens
+ * - Cannot contain spaces, uppercase, underscores, periods, or special characters
+ */
+export function validateStartupName(name: string): void {
+  if (!name || name.trim().length === 0) {
+    throw new Error('Startup name cannot be empty')
+  }
+
+  const validPattern = /^[a-z0-9-]+$/
+
+  if (!validPattern.test(name)) {
+    throw new InvalidStartupNameError(name)
+  }
+}

package/src/modules/workspace/commands/init-workspace.ts

@@ -0,0 +1,63 @@
+import * as path from 'path'
+
+import { input } from '@inquirer/prompts'
+import chalk from 'chalk'
+import { Command } from 'commander'
+import ora from 'ora'
+
+import { WorkspaceAlreadyExistsError, InvalidWorkspaceNameError } from '../errors/workspace-errors.js'
+import { WorkspaceService } from '../services/workspace-service.js'
+
+export function initWorkspaceCommand(): Command {
+  return new Command('init')
+    .argument('[name]', 'Name of the workspace (lowercase, alphanumeric, hyphens)')
+    .description('Initialize a new Launch77 workspace')
+    .action(async (name?: string) => {
+      // If no name provided, prompt for it
+      let workspaceName = name
+      if (!workspaceName) {
+        workspaceName = await input({
+          message: 'Workspace name:',
+          validate: (value) => {
+            if (!value || value.trim().length === 0) {
+              return 'Workspace name cannot be empty'
+            }
+            const validPattern = /^[a-z0-9-]+$/
+            if (!validPattern.test(value)) {
+              return 'Workspace name must be lowercase, alphanumeric, and hyphens only'
+            }
+            return true
+          },
+        })
+      }
+
+      console.log(chalk.blue(`\n🚀 Initializing workspace: ${workspaceName}\n`))
+
+      const service = new WorkspaceService()
+
+      try {
+        const spinner = ora('Creating workspace structure...').start()
+
+        const result = await service.initWorkspace({ name: workspaceName }, process.cwd())
+
+        spinner.succeed('Workspace structure created')
+
+        // Success message
+        const cwd = process.cwd()
+        console.log(chalk.green(`\n✅ Workspace created successfully at ${path.relative(cwd, result.workspacePath)}\n`))
+        console.log(chalk.gray(`Next steps:\n` + `  1. cd ${workspaceName}\n` + `  2. npm install\n` + `  3. Create your first app with launch77 commands\n`))
+      } catch (error) {
+        if (error instanceof WorkspaceAlreadyExistsError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          process.exit(1)
+        }
+
+        if (error instanceof InvalidWorkspaceNameError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          process.exit(1)
+        }
+
+        throw error
+      }
+    })
+}

package/src/modules/workspace/errors/workspace-errors.ts

@@ -0,0 +1,16 @@
+export class WorkspaceAlreadyExistsError extends Error {
+  constructor(
+    public workspaceName: string,
+    public workspacePath: string
+  ) {
+    super(`Workspace ${workspaceName} already exists at ${workspacePath}`)
+    this.name = 'WorkspaceAlreadyExistsError'
+  }
+}
+
+export class InvalidWorkspaceNameError extends Error {
+  constructor(public workspaceName: string) {
+    super(`Invalid workspace name: "${workspaceName}"\n\n` + `Workspace names must:\n` + `  • Be lowercase only\n` + `  • Can only contain: lowercase letters, numbers, and hyphens\n` + `  • Cannot contain: spaces, uppercase, underscores, periods, or special characters\n\n` + `Valid examples:\n` + `  ✓ my-workspace\n` + `  ✓ myworkspace\n` + `  ✓ workspace123\n\n` + `Invalid examples:\n` + `  ✗ MyWorkspace (uppercase)\n` + `  ✗ my_workspace (underscores)\n` + `  ✗ my.workspace (periods)\n` + `  ✗ my workspace (spaces)`)
+    this.name = 'InvalidWorkspaceNameError'
+  }
+}

package/src/modules/workspace/index.ts

@@ -0,0 +1,11 @@
+// Services
+export { WorkspaceService } from './services/workspace-service.js'
+
+// Types
+export type { InitWorkspaceRequest, InitWorkspaceResult } from './types/workspace-types.js'
+
+// Errors
+export { WorkspaceAlreadyExistsError, InvalidWorkspaceNameError } from './errors/workspace-errors.js'
+
+// Command
+export { initWorkspaceCommand } from './commands/init-workspace.js'

package/src/modules/workspace/services/workspace-service.ts

@@ -0,0 +1,59 @@
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+
+import * as filesystem from '../../../infrastructure/filesystem.js'
+import { WorkspaceAlreadyExistsError } from '../errors/workspace-errors.js'
+import { validateWorkspaceName } from '../utils/workspace-validators.js'
+
+import type { InitWorkspaceRequest, InitWorkspaceResult } from '../types/workspace-types.js'
+
+export class WorkspaceService {
+  async initWorkspace(request: InitWorkspaceRequest, cwd: string): Promise<InitWorkspaceResult> {
+    const { name } = request
+
+    // 1. Validate name
+    validateWorkspaceName(name)
+
+    // 2. Determine workspace path (relative to current directory)
+    const workspacePath = path.join(cwd, name)
+
+    // 3. Check if workspace already exists
+    if (await filesystem.exists(workspacePath)) {
+      throw new WorkspaceAlreadyExistsError(name, workspacePath)
+    }
+
+    // 4. Copy template
+    const templatePath = this.getTemplatePath()
+    await filesystem.copy(templatePath, workspacePath)
+
+    // 5. Update package.json with workspace name
+    const packageJsonPath = path.join(workspacePath, 'package.json')
+    const packageJson = await filesystem.readJSON<{ name?: string }>(packageJsonPath)
+    packageJson.name = name
+    await filesystem.writeJSON(packageJsonPath, packageJson)
+
+    // 6. Verify workspace.json was created
+    const workspaceJsonPath = path.join(workspacePath, '.launch77', 'workspace.json')
+    if (!(await filesystem.exists(workspaceJsonPath))) {
+      throw new Error('Failed to create workspace manifest (.launch77/workspace.json)')
+    }
+
+    return {
+      workspacePath,
+      name,
+    }
+  }
+
+  private getTemplatePath(): string {
+    const __filename = fileURLToPath(import.meta.url)
+    const __dirname = path.dirname(__filename)
+
+    // From src/modules/workspace/services/ or dist/modules/workspace/services/ up to cli root
+    const isDev = __filename.includes('/src/')
+    const cliRoot = isDev
+      ? path.join(__dirname, '../../../..') // src/modules/workspace/services -> cli root
+      : path.join(__dirname, '../../../..') // dist/modules/workspace/services -> cli root
+
+    return path.join(cliRoot, 'templates/workspace')
+  }
+}

package/src/modules/workspace/types/workspace-types.ts

@@ -0,0 +1,8 @@
+export interface InitWorkspaceRequest {
+  name: string
+}
+
+export interface InitWorkspaceResult {
+  workspacePath: string
+  name: string
+}

package/src/modules/workspace/utils/workspace-validators.ts

@@ -0,0 +1,19 @@
+import { InvalidWorkspaceNameError } from '../errors/workspace-errors.js'
+
+/**
+ * Validate workspace name format
+ * - Must be lowercase
+ * - Can only contain lowercase letters, numbers, and hyphens
+ * - Cannot contain spaces, uppercase, underscores, periods, or special characters
+ */
+export function validateWorkspaceName(name: string): void {
+  if (!name || name.trim().length === 0) {
+    throw new Error('Workspace name cannot be empty')
+  }
+
+  const validPattern = /^[a-z0-9-]+$/
+
+  if (!validPattern.test(name)) {
+    throw new InvalidWorkspaceNameError(name)
+  }
+}

package/src/utils/launch77-context.ts

@@ -0,0 +1,152 @@
+import * as path from 'path'
+
+import fs from 'fs-extra'
+
+export type Launch77LocationType = 'workspace-root' | 'workspace-app' | 'unknown'
+
+export interface Launch77Context {
+  isValid: boolean
+  locationType: Launch77LocationType
+  workspaceRoot: string
+  appsDir: string
+  workspaceVersion: string
+  workspaceName: string
+  appName?: string
+  packageName: string
+}
+
+const WORKSPACE_MANIFEST = '.launch77/workspace.json'
+
+interface WorkspaceManifest {
+  version: string
+}
+
+/**
+ * Check if a directory contains a Launch77 workspace manifest
+ */
+async function isWorkspaceRoot(dir: string): Promise<boolean> {
+  const manifestPath = path.join(dir, WORKSPACE_MANIFEST)
+  return await fs.pathExists(manifestPath)
+}
+
+/**
+ * Read workspace manifest
+ */
+async function readWorkspaceManifest(workspaceRoot: string): Promise<WorkspaceManifest> {
+  const manifestPath = path.join(workspaceRoot, WORKSPACE_MANIFEST)
+  return await fs.readJSON(manifestPath)
+}
+
+/**
+ * Find the workspace root by traversing up from a starting directory
+ * Looks for .launch77/workspace.json manifest file
+ */
+async function findWorkspaceRoot(startDir: string): Promise<string | null> {
+  let currentDir = path.resolve(startDir)
+  const rootDir = path.parse(currentDir).root
+
+  while (currentDir !== rootDir) {
+    if (await isWorkspaceRoot(currentDir)) {
+      return currentDir
+    }
+    currentDir = path.dirname(currentDir)
+  }
+
+  return null
+}
+
+interface ParsedLocation {
+  locationType: Launch77LocationType
+  appName?: string
+}
+
+/**
+ * Parse the directory structure to determine location context
+ * Based on patterns:
+ * - apps/[name] → workspace-app
+ * - (empty or root) → workspace-root
+ */
+function parseLocationFromPath(cwdPath: string, workspaceRoot: string): ParsedLocation {
+  const relativePath = path.relative(workspaceRoot, cwdPath)
+
+  // At workspace root
+  if (!relativePath || relativePath === '.') {
+    return { locationType: 'workspace-root' }
+  }
+
+  const parts = relativePath.split(path.sep)
+
+  // apps/[app-name]/...
+  if (parts[0] === 'apps' && parts.length >= 2) {
+    return {
+      locationType: 'workspace-app',
+      appName: parts[1],
+    }
+  }
+
+  // Somewhere else in workspace (libraries, plugins, etc.)
+  // Still considered workspace-root for now
+  return { locationType: 'workspace-root' }
+}
+
+/**
+ * Detect the Launch77 workspace context from the current working directory
+ */
+export async function detectLaunch77Context(cwd: string): Promise<Launch77Context> {
+  const resolvedCwd = path.resolve(cwd)
+
+  // Find the workspace root
+  const workspaceRoot = await findWorkspaceRoot(resolvedCwd)
+
+  if (!workspaceRoot) {
+    return {
+      isValid: false,
+      locationType: 'unknown',
+      workspaceRoot: '',
+      appsDir: '',
+      workspaceVersion: '',
+      workspaceName: '',
+      packageName: '',
+    }
+  }
+
+  // Read workspace manifest
+  let manifest: WorkspaceManifest
+  try {
+    manifest = await readWorkspaceManifest(workspaceRoot)
+  } catch (error) {
+    // Manifest exists (we found it) but couldn't read it
+    return {
+      isValid: false,
+      locationType: 'unknown',
+      workspaceRoot: '',
+      appsDir: '',
+      workspaceVersion: '',
+      workspaceName: '',
+      packageName: '',
+    }
+  }
+
+  // Parse the directory structure to determine location
+  const parsed = parseLocationFromPath(resolvedCwd, workspaceRoot)
+
+  // Workspace name is the directory name
+  const workspaceName = path.basename(workspaceRoot)
+
+  // Apps directory is always {workspaceRoot}/apps
+  const appsDir = path.join(workspaceRoot, 'apps')
+
+  // Package name: @{workspaceName}/{appName} (if in app)
+  const packageName = parsed.appName ? `@${workspaceName}/${parsed.appName}` : ''
+
+  return {
+    isValid: true,
+    locationType: parsed.locationType,
+    workspaceRoot,
+    appsDir,
+    workspaceVersion: manifest.version,
+    workspaceName,
+    appName: parsed.appName,
+    packageName,
+  }
+}

package/src/utils/launch77-validation.ts

@@ -0,0 +1,59 @@
+import type { Launch77Context } from './launch77-context.js'
+
+/**
+ * Validation result with helpful error messages
+ */
+export interface ValidationResult {
+  valid: boolean
+  errorMessage?: string
+}
+
+/**
+ * Validate that we're in a workspace context for app:create
+ */
+export function validateWorkspaceContext(context: Launch77Context): ValidationResult {
+  if (!context.isValid) {
+    return {
+      valid: false,
+      errorMessage: 'Must be run from within a Launch77 workspace.\n\n' + 'Create a workspace first:\n' + '  launch77 init my-workspace\n' + '  cd my-workspace',
+    }
+  }
+
+  if (context.locationType !== 'workspace-root' && context.locationType !== 'workspace-app') {
+    return {
+      valid: false,
+      errorMessage: 'Must be run from workspace root or app directory',
+    }
+  }
+
+  return { valid: true }
+}
+
+/**
+ * Validate that we're inside an app directory (for plugin:install - future use)
+ */
+export function validateAppContext(context: Launch77Context): ValidationResult {
+  if (!context.isValid) {
+    return {
+      valid: false,
+      errorMessage: 'Must be run from within a Launch77 workspace app directory',
+    }
+  }
+
+  // Must be inside an app, not just workspace root
+  if (context.locationType !== 'workspace-app') {
+    return {
+      valid: false,
+      errorMessage: 'plugin:install must be run from within an app directory.\n\n' + 'Navigate to an app:\n' + '  cd apps/<app-name>',
+    }
+  }
+
+  if (!context.appName) {
+    return {
+      valid: false,
+      errorMessage: 'Could not determine app name from current directory.\nThis is a bug. Please report it.',
+    }
+  }
+
+  return { valid: true }
+}

package/src/utils/monorepo.ts

@@ -0,0 +1,137 @@
+import * as path from 'path'
+
+import fs from 'fs-extra'
+
+export type LocationType = 'monorepo-root' | 'startup-root' | 'startup-app' | 'unknown'
+
+export interface MonorepoContext {
+  isValid: boolean
+  location: LocationType
+  monorepoRoot: string
+  appsDir: string | null
+  // Specific context info
+  startupName?: string
+  appName?: string
+  packageName?: string
+}
+
+const MONOREPO_ROOT_MARKER = '.launch-monorepo-root.md'
+
+/**
+ * Check if a directory is the monorepo root by looking for the marker file
+ */
+async function isMonorepoRoot(dir: string): Promise<boolean> {
+  const markerPath = path.join(dir, MONOREPO_ROOT_MARKER)
+  return await fs.pathExists(markerPath)
+}
+
+/**
+ * Find the monorepo root by traversing up from a starting directory
+ * Looks for .launch-monorepo-root.md marker file
+ */
+async function findMonorepoRoot(startDir: string): Promise<string | null> {
+  let currentDir = path.resolve(startDir)
+  const rootDir = path.parse(currentDir).root
+
+  while (currentDir !== rootDir) {
+    if (await isMonorepoRoot(currentDir)) {
+      return currentDir
+    }
+    currentDir = path.dirname(currentDir)
+  }
+
+  return null
+}
+
+interface ParsedLocation {
+  location: LocationType
+  startupName?: string
+  appName?: string
+}
+
+/**
+ * Parse the directory structure to determine location context
+ * Based on patterns:
+ * - startups/[name] → startup-root
+ * - startups/[name]/apps/[app] → startup-app
+ * - (empty or root) → monorepo-root
+ */
+function parseLocationFromPath(cwdPath: string, monorepoRoot: string): ParsedLocation {
+  const relativePath = path.relative(monorepoRoot, cwdPath)
+
+  // At monorepo root
+  if (!relativePath || relativePath === '.') {
+    return { location: 'monorepo-root' }
+  }
+
+  const parts = relativePath.split(path.sep)
+
+  // startups/[name]/...
+  if (parts[0] === 'startups' && parts.length >= 2) {
+    const startupName = parts[1]
+
+    // startups/[name]/apps/[app]
+    if (parts.length >= 4 && parts[2] === 'apps') {
+      return {
+        location: 'startup-app',
+        startupName,
+        appName: parts[3],
+      }
+    }
+
+    // startups/[name]
+    return {
+      location: 'startup-root',
+      startupName,
+    }
+  }
+
+  return { location: 'unknown' }
+}
+
+/**
+ * Determine the apps directory based on location context
+ * Returns null for invalid locations (e.g., monorepo-root, unknown)
+ */
+function getAppsDir(monorepoRoot: string, location: LocationType, startupName?: string): string | null {
+  if (location === 'startup-root' || location === 'startup-app') {
+    return path.join(monorepoRoot, 'startups', startupName!, 'apps')
+  }
+  return null
+}
+
+/**
+ * Detect the monorepo context from the current working directory
+ *
+ * @deprecated Use detectLaunch77Context() from launch77-context.ts instead.
+ * This function is maintained for legacy monorepo structure only.
+ * New workspaces created with `launch77 init` should use the new context system.
+ */
+export async function detectMonorepoContext(cwd: string): Promise<MonorepoContext> {
+  const resolvedCwd = path.resolve(cwd)
+
+  // Find the monorepo root
+  const monorepoRoot = await findMonorepoRoot(resolvedCwd)
+
+  if (!monorepoRoot) {
+    return {
+      isValid: false,
+      location: 'unknown',
+      monorepoRoot: '',
+      appsDir: null,
+    }
+  }
+
+  // Parse the directory structure to determine location
+  const parsed = parseLocationFromPath(resolvedCwd, monorepoRoot)
+  const appsDir = getAppsDir(monorepoRoot, parsed.location, parsed.startupName)
+
+  return {
+    isValid: true,
+    location: parsed.location,
+    monorepoRoot,
+    appsDir,
+    startupName: parsed.startupName,
+    appName: parsed.appName,
+  }
+}

package/src/utils/validation.ts

@@ -0,0 +1,117 @@
+import * as path from 'path'
+
+import chalk from 'chalk'
+
+import type { MonorepoContext } from './monorepo.js'
+
+/**
+ * Validation result with helpful error messages
+ */
+export interface ValidationResult {
+  valid: boolean
+  errorMessage?: string
+}
+
+/**
+ * Validate that we're in a startup context (for create-app)
+ */
+export function validateStartupContext(context: MonorepoContext): ValidationResult {
+  if (!context.isValid) {
+    return {
+      valid: false,
+      errorMessage: 'Must be run from within a Launch77 monorepo (could not find .launch-monorepo-root.md)',
+    }
+  }
+
+  if (context.location !== 'startup-root' && context.location !== 'startup-app') {
+    return {
+      valid: false,
+      errorMessage: `Command must be run from a startup directory.\n\n` + `${chalk.gray('Current location:')} ${context.location}\n` + `${chalk.gray('Expected:')} Within startups/<startup-name>/\n\n` + `${chalk.yellow('Navigate to a startup first:')}\n` + `  cd startups/<startup-name>/\n\n` + `${chalk.yellow('Or create a startup:')}\n` + `  launch77 create-startup <startup-name>`,
+    }
+  }
+
+  if (!context.appsDir) {
+    return {
+      valid: false,
+      errorMessage: `Could not determine apps directory for location: ${context.location}\n` + `This is a bug. Please report it.`,
+    }
+  }
+
+  return { valid: true }
+}
+
+/**
+ * Validate that we're inside an app directory (for plugin:install)
+ */
+export function validateAppContext(context: MonorepoContext): ValidationResult {
+  if (!context.isValid) {
+    return {
+      valid: false,
+      errorMessage: 'Must be run from within a Launch77 monorepo (could not find .launch-monorepo-root.md)',
+    }
+  }
+
+  // Must be inside an app, not just a startup
+  if (context.location !== 'startup-app') {
+    return {
+      valid: false,
+      errorMessage: `plugin:install must be run from within an app directory.\n\n` + `${chalk.gray('Current location:')} ${context.location}\n` + `${chalk.gray('Expected:')} startups/<startup-name>/apps/<app-name>/\n\n` + `${chalk.yellow('Navigate to an app directory:')}\n` + `  cd startups/<startup-name>/apps/<app-name>/\n\n` + `${chalk.yellow('Or create an app first:')}\n` + `  cd startups/<startup-name>/\n` + `  launch77 app:create api <app-name>`,
+    }
+  }
+
+  if (!context.appName) {
+    return {
+      valid: false,
+      errorMessage: `Could not determine app name from current directory.\n` + `This is a bug. Please report it.`,
+    }
+  }
+
+  return { valid: true }
+}
+
+/**
+ * Get the app directory path
+ * Returns null if not in an app context
+ */
+export function getAppDirectory(context: MonorepoContext): string | null {
+  if (context.location !== 'startup-app') {
+    return null
+  }
+
+  if (!context.monorepoRoot || !context.startupName || !context.appName) {
+    return null
+  }
+
+  return path.join(context.monorepoRoot, 'startups', context.startupName, 'apps', context.appName)
+}
+
+/**
+ * Validate app name format
+ *
+ * App names must follow Launch77 naming conventions:
+ * - Must be lowercase
+ * - Must start with a letter [a-z]
+ * - Can only contain lowercase letters, numbers, and hyphens
+ * - Cannot contain spaces, uppercase, underscores, periods, or special characters
+ */
+export function validateAppName(appName: string): ValidationResult {
+  // Check for empty name
+  if (!appName || appName.trim().length === 0) {
+    return {
+      valid: false,
+      errorMessage: 'App name cannot be empty',
+    }
+  }
+
+  // Launch77 naming convention: lowercase, letters, numbers, hyphens only
+  const validPattern = /^[a-z][a-z0-9-]*$/
+
+  if (!validPattern.test(appName)) {
+    return {
+      valid: false,
+      errorMessage: `Invalid app name: "${appName}"\n\n` + `${chalk.gray('App names must:')}\n` + `  • Be lowercase only\n` + `  • Start with a letter\n` + `  • Can only contain: lowercase letters, numbers, and hyphens\n` + `  • Cannot contain: spaces, uppercase, underscores, periods, or special characters\n\n` + `${chalk.yellow('Valid examples:')}\n` + `  ✓ my-app\n` + `  ✓ myapp\n` + `  ✓ myapp123\n` + `  ✓ app-123\n\n` + `${chalk.red('Invalid examples:')}\n` + `  ✗ MyApp (uppercase)\n` + `  ✗ my_app (underscores)\n` + `  ✗ my.app (periods)\n` + `  ✗ my app (spaces)\n` + `  ✗ @myapp (special characters)\n` + `  ✗ -myapp (starts with hyphen)\n` + `  ✗ 123app (starts with number)`,
+    }
+  }
+
+  return { valid: true }
+}