@forgehive/forge-cli 0.3.10 → 0.3.11

package/src/tasks/auth/list.ts

@@ -25,19 +25,33 @@ export const list = createTask({
       return { status: 'Ok', profiles: [] }
     }
 
-    console.log('Available profiles:')
+    // Show current profile
+    const currentProfile = profiles.profiles.find(profile => profile.name === profiles.default)
+    if (currentProfile) {
+      console.log('Current Profile:')
+      console.log(`  Name: ${currentProfile.name}`)
+      console.log(`  API Key: ${currentProfile.apiKey}`)
+      console.log(`  URL: ${currentProfile.url}`)
+      console.log('')
+    }
+
+    console.log('Available profiles:\n')
+
+    const tableData = profiles.profiles.map(profile => ({
+      Name: profile.name,
+      'API Key': profile.apiKey,
+      URL: profile.url
+    }))
 
-    profiles.profiles.forEach(profile => {
-      const isDefault = profile.name === profiles.default
-      const prefix = isDefault ? '* ' : '  '
-      console.log(`${prefix}${profile.name} - API Key: ${profile.apiKey}`)
-    })
+    console.table(tableData, ['Name', 'API Key', 'URL'])
 
     console.log('\nUse auth:add to create or update a profile')
-    console.log('\nUse auth:switch to switch to a profile')
+    console.log('Use auth:switch [name] or auth:switch [index] to switch profiles')
+    console.log('========================================')
 
     return {
-      default: profiles.default
+      default: profiles.default,
+      profiles: tableData
     }
   }
 })

package/src/tasks/auth/switch.ts

@@ -1,6 +1,6 @@
 // TASK: switch
 // Run this task with:
-// forge task:run auth:switch --profileName [name]
+// forge auth:switch [name] or forge auth:switch [index]
 
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
@@ -31,23 +31,39 @@ export const switchProfile = createTask({
     // Load profiles
     const profiles = await loadProfiles({})
 
-    // Check if profile exists
-    const profileExists = profiles.profiles.some(profile => profile.name === profileName)
+    if (profiles.profiles.length === 0) {
+      throw new Error('No profiles found. Use auth:add to create one.')
+    }
+
+    let targetProfile: string
 
-    if (!profileExists) {
-      throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`)
+    // Check if profileName is a number (index)
+    const indexInput = parseInt(profileName, 10)
+    if (!isNaN(indexInput)) {
+      // Using index
+      if (indexInput < 0 || indexInput >= profiles.profiles.length) {
+        throw new Error(`Profile index ${indexInput} is out of range. Use auth:list to see available profiles (0-${profiles.profiles.length - 1}).`)
+      }
+      targetProfile = profiles.profiles[indexInput].name
+    } else {
+      // Using profile name
+      const profileExists = profiles.profiles.some(profile => profile.name === profileName)
+      if (!profileExists) {
+        throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`)
+      }
+      targetProfile = profileName
     }
 
     // Update default profile
-    profiles.default = profileName
+    profiles.default = targetProfile
 
     // Save updated profiles
     await persistProfiles(profiles)
 
-    console.log(`Switched to profile: ${profileName}`)
+    console.log(`Switched to profile: ${targetProfile}`)
 
     return {
-      default: profileName
+      default: targetProfile
     }
   }
 })

package/src/tasks/project/README.md

@@ -0,0 +1,268 @@
+# Project Commands
+
+This directory contains ForgeHive CLI commands for project management operations.
+
+## Commands
+
+### `project:create`
+
+Creates a new project in ForgeHive with automatic UUID generation and API integration.
+
+#### Usage
+
+```bash
+forge project:create [--projectName="My Project"] [--description="Project description"]
+```
+
+#### Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `projectName` | string | No | Name of the project to create. If not provided, uses the project name from `forge.json` |
+| `description` | string | No | Optional description for the project |
+
+#### Behavior
+
+1. **UUID Management**: Checks if the local `forge.json` has a project UUID
+   - If no UUID exists, generates a new UUID v4 and saves it to `forge.json`
+   - If UUID already exists, uses the existing one
+
+2. **Authentication**: Uses the current profile from `auth:list` for API authentication
+   - Requires a valid profile set via `auth:add` and `auth:switch`
+   - Uses profile's `apiKey`, `apiSecret`, and `url` for the request
+
+3. **API Request**: Makes a POST request to `/api/projects` with:
+   - `projectName`: The provided project name
+   - `description`: The provided description (or empty string if not provided)
+   - `uuid`: The project UUID (generated or existing)
+
+4. **Response**: Returns the created project details including:
+   - Project UUID
+   - Project name
+   - Team information
+   - Creation timestamps
+
+#### Examples
+
+```bash
+# Create a project using the name from forge.json
+forge project:create
+
+# Create a project with custom name
+forge project:create --projectName="My New Project"
+
+# Create a project with custom name and description
+forge project:create --projectName="Analytics Dashboard" --description="Customer analytics and reporting platform"
+
+# Create a project using forge.json name but with description
+forge project:create --description="Using the default project name from configuration"
+```
+
+#### Success Output
+
+```
+Generated and saved project UUID: 550e8400-e29b-41d4-a716-446655440000
+Project created successfully!
+Project UUID: 550e8400-e29b-41d4-a716-446655440000
+Project Name: My New Project
+
+🌐 View your project on the dashboard: https://api.forgehive.com/dashboard/projects/550e8400-e29b-41d4-a716-446655440000
+```
+
+#### Error Cases
+
+- **No Project Name**: If no `--projectName` is provided and `forge.json` doesn't contain a project name
+- **No Profile**: If no authentication profile is configured
+- **Invalid Profile**: If the current profile is invalid or expired
+- **API Errors**: Network issues, server errors, or validation failures
+- **Duplicate Names**: If a project with the same name already exists in the team
+
+#### File Changes
+
+When run, this command may modify:
+- `forge.json`: Adds or updates the project UUID if one doesn't exist
+
+#### Dependencies
+
+- Requires `@forgehive/task` framework
+- Requires `@forgehive/schema` for validation
+- Uses `uuid` package for UUID generation
+- Integrates with `auth:loadCurrent` for profile management
+- Integrates with `conf:load` for configuration management
+
+#### API Integration
+
+This command integrates with the ForgeHive Projects API. See the [Projects API Documentation](../../../../../../../hive/docs/projects-api.md) for detailed API specifications.
+
+---
+
+## Project Configuration
+
+Projects are configured via the `forge.json` file in your project root:
+
+```json
+{
+  "project": {
+    "name": "My Project",
+    "uuid": "550e8400-e29b-41d4-a716-446655440000"
+  }
+}
+```
+
+The UUID is automatically generated and managed by the CLI commands.
+
+---
+
+### `project:link`
+
+Links an existing remote project to the local project by validating the UUID and updating forge.json.
+
+#### Usage
+
+```bash
+forge project:link [uuid]
+```
+
+#### Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `uuid` | string (UUID) | Yes | UUID of the existing remote project to link |
+
+#### Behavior
+
+1. **UUID Validation**: Validates the provided UUID format using regex
+2. **Remote Verification**: Makes a GET request to `/api/projects/{uuid}` to verify the project exists
+3. **Authentication**: Uses the current profile for API authentication
+4. **Project Details**: Displays project information (name, description, task count) if found
+5. **Local Update**: Updates the local `forge.json` with the verified UUID
+
+#### Examples
+
+```bash
+# Link to an existing remote project
+forge project:link 550e8400-e29b-41d4-a716-446655440000
+```
+
+#### Success Output
+
+```
+Checking if project 550e8400-e29b-41d4-a716-446655440000 exists on https://api.forgehive.com...
+✓ Found project: Customer Analytics
+  Description: Analytics platform for customer behavior analysis
+  Tasks: 3 task(s)
+
+✓ Successfully linked project 550e8400-e29b-41d4-a716-446655440000 to local forge.json
+  Local project name: My Local Project
+  Remote project name: Customer Analytics
+
+🌐 View your project on the dashboard: https://api.forgehive.com/dashboard/projects/550e8400-e29b-41d4-a716-446655440000
+```
+
+#### Error Cases
+
+- **Invalid UUID Format**: If the provided UUID doesn't match the expected format
+- **Project Already Linked**: If the local project already has a UUID in forge.json
+- **Project Not Found**: If the UUID doesn't exist on the remote server (404)
+- **Authentication Failed**: If the current profile credentials are invalid (401)
+- **No Profile**: If no authentication profile is configured
+- **Network Issues**: Connection problems or server errors
+
+#### Error Examples
+
+```bash
+# Invalid UUID format
+forge project:link invalid-uuid
+# Error: Invalid UUID format: invalid-uuid. Please provide a valid UUID.
+
+# Project already linked
+forge project:link 550e8400-e29b-41d4-a716-446655440000
+# Error: Project is already linked to UUID: 123e4567-e89b-12d3-a456-426614174000. Use a different project or remove the existing UUID from forge.json first.
+
+# Project not found
+forge project:link 00000000-0000-0000-0000-000000000000
+# Error: Project with UUID 00000000-0000-0000-0000-000000000000 not found on https://api.forgehive.com. Please verify the UUID is correct.
+
+# Authentication failed
+forge project:link 550e8400-e29b-41d4-a716-446655440000
+# Error: Authentication failed. Please check your profile credentials with 'forge auth:list'.
+```
+
+#### File Changes
+
+When run successfully, this command modifies:
+- `forge.json`: Updates the `project.uuid` field with the verified remote project UUID
+
+#### Dependencies
+
+- Requires `@forgehive/task` framework
+- Requires `@forgehive/schema` for validation
+- Integrates with `auth:loadCurrent` for profile management
+- Integrates with `conf:load` for configuration management
+- Uses the ForgeHive Projects API `/api/projects/{uuid}` endpoint
+
+---
+
+### `project:unlink`
+
+Removes the project UUID link from the local forge.json, allowing the project to be linked to a different remote project.
+
+#### Usage
+
+```bash
+forge project:unlink
+```
+
+#### Parameters
+
+This command takes no parameters.
+
+#### Behavior
+
+1. **UUID Check**: Verifies that a project UUID exists in forge.json
+2. **Local Update**: Removes the UUID field from the project configuration
+3. **Confirmation**: Shows the UUID that was removed and next steps
+
+#### Examples
+
+```bash
+# Unlink the current project
+forge project:unlink
+```
+
+#### Success Output
+
+```
+✓ Successfully unlinked project from UUID: 550e8400-e29b-41d4-a716-446655440000
+  The project is no longer linked to a remote project.
+  You can now link to a different project using 'forge project:link [uuid]'
+```
+
+#### Error Cases
+
+- **No UUID Found**: If the project is not currently linked (no UUID in forge.json)
+
+#### Error Examples
+
+```bash
+# No project linked
+forge project:unlink
+# Error: No project UUID found in forge.json. The project is not currently linked to a remote project.
+```
+
+#### File Changes
+
+When run successfully, this command modifies:
+- `forge.json`: Removes the `project.uuid` field completely
+
+#### Dependencies
+
+- Requires `@forgehive/task` framework
+- Requires `@forgehive/schema` for validation
+- Integrates with `conf:load` for configuration management
+
+**Note**: This command only affects the local forge.json file. It does not make any API calls or modify anything on the remote server.
+
+---
+
+## Project Configuration

package/src/tasks/project/create.ts

@@ -0,0 +1,111 @@
+// TASK: create
+// Run this task with:
+// forge task:run project:create
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import { v4 as uuidv4 } from 'uuid'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { load as loadConf } from '../conf/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { type ForgeConf, type Profile } from '../types'
+
+const name = 'project:create'
+const description = 'Create a new project in ForgeHive'
+
+const schema = new Schema({
+  projectName: Schema.string().optional(),
+  description: Schema.string().optional()
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  writeFile: async (filePath: string, content: string): Promise<void> => {
+    await fs.writeFile(filePath, content, 'utf-8')
+  },
+  createProject: async (profile: Profile, payload: { projectName: string; description: string; uuid: string }): Promise<Response> => {
+    const authToken = `${profile.apiKey}:${profile.apiSecret}`
+    return await fetch(`${profile.url}/api/projects`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${authToken}`
+      },
+      body: JSON.stringify(payload)
+    })
+  }
+}
+
+export const create = createTask({
+  name,
+  description,
+  schema,
+  boundaries,
+  fn: async function (argv, { loadConf, loadCurrentProfile, writeFile, createProject }) {
+    const { projectName: inputProjectName, description } = argv
+
+    // Load current configuration
+    const conf = await loadConf({})
+
+    // Use provided projectName or fall back to forge.json project name
+    const projectName = inputProjectName || conf.project.name
+
+    if (!projectName) {
+      throw new Error('Project name is required. Provide --projectName or ensure forge.json has a project name.')
+    }
+
+    // Check if project already has a UUID, generate one if not
+    let projectUuid = conf.project.uuid
+    if (!projectUuid) {
+      projectUuid = uuidv4()
+
+      // Update forge.json with the new UUID
+      const forgePath = path.join(process.cwd(), 'forge.json')
+      const updatedConf: ForgeConf = {
+        ...conf,
+        project: {
+          ...conf.project,
+          uuid: projectUuid
+        }
+      }
+
+      await writeFile(forgePath, JSON.stringify(updatedConf, null, 2))
+      console.log(`Generated and saved project UUID: ${projectUuid}`)
+    }
+
+    // Load current profile for API authentication
+    const profile = await loadCurrentProfile({})
+
+    // Prepare API request payload
+    const payload = {
+      projectName,
+      description: description || '',
+      uuid: projectUuid
+    }
+
+    // Make API request to create project
+    const response = await createProject(profile, payload)
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      throw new Error(`Failed to create project: ${response.status} ${response.statusText} - ${errorText}`)
+    }
+
+    const result = await response.json()
+
+    console.log('Project created successfully!')
+    console.log(`Project UUID: ${result.project.uuid}`)
+    console.log(`Project Name: ${result.project.projectName}`)
+    console.log(`\n🌐 View your project on the dashboard: ${profile.url}/dashboard/projects/${result.project.uuid}`)
+
+    return {
+      success: true,
+      project: result.project,
+      localUuid: projectUuid
+    }
+  }
+})
+

package/src/tasks/project/link.ts

@@ -0,0 +1,106 @@
+// TASK: link
+// Run this task with:
+// forge project:link [uuid]
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { load as loadConf } from '../conf/load'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { type ForgeConf, type Profile } from '../types'
+
+const name = 'project:link'
+const description = 'Link an existing remote project to the local project by UUID'
+
+const schema = new Schema({
+  uuid: Schema.string()
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
+  writeFile: async (filePath: string, content: string): Promise<void> => {
+    await fs.writeFile(filePath, content, 'utf-8')
+  },
+  fetchProject: async (profile: Profile, uuid: string): Promise<Response> => {
+    const authToken = `${profile.apiKey}:${profile.apiSecret}`
+    console.log(`Fetching project ${uuid} from ${profile.url}...`)
+    return await fetch(`${profile.url}/api/projects/${uuid}`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${authToken}`
+      }
+    })
+  }
+}
+
+export const link = createTask({
+  name,
+  description,
+  schema,
+  boundaries,
+  fn: async function ({ uuid }, { loadConf, loadCurrentProfile, writeFile, fetchProject }) {
+    // Load current configuration and profile
+    const conf = await loadConf({})
+
+    // Check if project already has a UUID
+    if (conf.project.uuid) {
+      throw new Error(`Project is already linked to UUID: ${conf.project.uuid}. Use a different project or remove the existing UUID from forge.json first.`)
+    }
+
+    const profile = await loadCurrentProfile({})
+
+    console.log(`Checking if project ${uuid} exists on ${profile.url}...`)
+
+    // Check if project exists on remote
+    const response = await fetchProject(profile, uuid)
+
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`Project with UUID ${uuid} not found on ${profile.url}. Please verify the UUID is correct.`)
+      } else if (response.status === 401) {
+        throw new Error('Authentication failed. Please check your profile credentials with \'forge auth:list\'.')
+      } else {
+        const errorText = await response.text()
+        throw new Error(`Failed to verify project: ${response.status} ${response.statusText} - ${errorText}`)
+      }
+    }
+
+    const projectData = await response.json()
+    const project = projectData.project
+
+    console.log(`✓ Found project: ${project.projectName}`)
+    console.log(`  Description: ${project.description || 'No description'}`)
+    console.log(`  Tasks: ${project.tasks.length} task(s)`)
+
+    // Update forge.json with the UUID
+    const forgePath = path.join(process.cwd(), 'forge.json')
+    const updatedConf: ForgeConf = {
+      ...conf,
+      project: {
+        ...conf.project,
+        uuid: uuid
+      }
+    }
+
+    await writeFile(forgePath, JSON.stringify(updatedConf, null, 2))
+
+    console.log(`\n✓ Successfully linked project ${uuid} to local forge.json`)
+    console.log(`  Local project name: ${conf.project.name}`)
+    console.log(`  Remote project name: ${project.projectName}`)
+    console.log(`\n🌐 View your project on the dashboard: ${profile.url}/dashboard/projects/${uuid}`)
+
+    return {
+      success: true,
+      linkedProject: {
+        uuid: project.uuid,
+        name: project.projectName,
+        description: project.description,
+        tasksCount: project.tasks.length
+      }
+    }
+  }
+})
+

package/src/tasks/project/unlink.ts

@@ -0,0 +1,74 @@
+// TASK: unlink
+// Run this task with:
+// forge project:unlink
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { load as loadConf } from '../conf/load'
+import { type ForgeConf } from '../types'
+
+const name = 'project:unlink'
+const description = 'Remove the project UUID link from local forge.json'
+
+const schema = new Schema({
+  // No parameters needed for unlink
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  writeFile: async (filePath: string, content: string): Promise<void> => {
+    await fs.writeFile(filePath, content, 'utf-8')
+  }
+}
+
+export const unlink = createTask({
+  name,
+  description,
+  schema,
+  boundaries,
+  fn: async function (argv, { loadConf, writeFile }) {
+    // Load current configuration
+    const conf = await loadConf({})
+
+    // Check if project has a UUID to unlink
+    if (!conf.project.uuid) {
+      throw new Error('No project UUID found in forge.json. The project is not currently linked to a remote project.')
+    }
+
+    const currentUuid = conf.project.uuid
+
+    // Remove the UUID from the project configuration
+    const updatedConf: ForgeConf = {
+      ...conf,
+      project: {
+        ...conf.project,
+        uuid: undefined
+      }
+    }
+
+    // Clean up undefined values by creating a new object without the uuid field
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { uuid, ...projectWithoutUuid } = updatedConf.project
+    const finalConf: ForgeConf = {
+      ...updatedConf,
+      project: projectWithoutUuid
+    }
+
+    // Write the updated configuration back to forge.json
+    const forgePath = path.join(process.cwd(), 'forge.json')
+    await writeFile(forgePath, JSON.stringify(finalConf, null, 2))
+
+    console.log(`✓ Successfully unlinked project from UUID: ${currentUuid}`)
+    console.log('  The project is no longer linked to a remote project.')
+    console.log('  You can now link to a different project using \'forge project:link [uuid]\'')
+
+    return {
+      success: true,
+      unlinkedUuid: currentUuid
+    }
+  }
+})
+

package/src/tasks/task/createTask.ts

@@ -1,5 +1,6 @@
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
+import { v4 as uuidv4 } from 'uuid'
 
 import Handlebars from 'handlebars'
 import path from 'path'
@@ -38,11 +39,10 @@ export const {{ taskName }} = createTask({
   boundaries,
   fn: async function (argv, boundaries) {
     console.log('input:', argv)
-    console.log('boundaries:', boundaries)
+    console.log('boundaries:', Object.keys(boundaries))
     // Your task implementation goes here
-    const status = { status: 'Ok' }
 
-    return status
+    return {}
   }
 })
 
@@ -155,7 +155,8 @@ export const createTaskCommand = createTask({
 
     forge.tasks[descriptor] = {
       path: `${taskPath}/${fileName}`,
-      handler: taskName
+      handler: taskName,
+      uuid: uuidv4()
     }
 
     await persistConf(forge, cwd)

package/src/tasks/types.ts

@@ -10,6 +10,7 @@ export interface RunnerDescriptor {
 export interface TaskDescriptor {
   path: string
   handler: string
+  uuid?: string
 }
 
 export interface Infra {