@forgehive/forge-cli 0.3.17 → 0.5.1

package/dist/runner.js

@@ -75,10 +75,78 @@ runner.load('project:create', create_2.create);
 runner.load('project:link', link_1.link);
 runner.load('project:unlink', unlink_1.unlink);
 runner.load('project:sync', sync_1.sync);
+function printAllHelp() {
+    const tasks = runner.describe();
+    console.log('Usage: forge <command> [options]');
+    console.log('');
+    console.log('Commands:');
+    const groups = {};
+    for (const name of Object.keys(tasks).sort()) {
+        const group = name.includes(':') ? name.split(':')[0] : name;
+        if (!groups[group]) {
+            groups[group] = [];
+        }
+        groups[group].push(name);
+    }
+    for (const [group, commands] of Object.entries(groups)) {
+        console.log(`\n  ${group}:`);
+        for (const cmd of commands) {
+            const desc = tasks[cmd].description || '';
+            console.log(`    ${cmd.padEnd(26)} ${desc}`);
+        }
+    }
+    console.log('');
+    console.log('Run "forge <command> --help" for more information on a specific command.');
+}
+function printTaskHelp(taskName) {
+    const task = runner.getTask(taskName);
+    if (!task) {
+        return;
+    }
+    // `describe()` returns JSON Schema: fields live under `properties`, optionality
+    // is the absence from `required`, and `description` carries the help text.
+    const schema = task.describe();
+    const properties = (schema.properties ?? {});
+    const required = new Set((schema.required ?? []));
+    const keys = Object.keys(properties);
+    console.log(`Usage: forge ${taskName}${keys.length > 0 ? ' [options]' : ''}`);
+    console.log('');
+    const desc = task.getDescription();
+    if (desc) {
+        console.log(desc);
+        console.log('');
+    }
+    if (keys.length > 0) {
+        console.log('Options:');
+        for (const key of keys) {
+            const field = properties[key];
+            const type = field.format ?? field.type ?? 'unknown';
+            const optional = required.has(key) ? '' : ' (optional)';
+            const description = field.description ? ` - ${field.description}` : '';
+            console.log(`  --${key.padEnd(20)} ${`${type}${optional}`.padEnd(20)}${description}`);
+        }
+        console.log('');
+    }
+    else {
+        console.log('This command takes no options.');
+        console.log('');
+    }
+}
 // Set handler
 runner.setHandler(async (data) => {
     const parsedArgs = runner.parseArguments(data);
     const { taskName, action, args } = parsedArgs;
+    const helpRequested = args?.help === true;
+    if (helpRequested || taskName === 'undefined' || !taskName) {
+        if (helpRequested && runner.getTask(taskName)) {
+            printTaskHelp(taskName);
+        }
+        else {
+            printAllHelp();
+        }
+        setTimeout(() => { process.exit(0); }, 100);
+        return { silent: true, outcome: 'Success', taskName, result: null };
+    }
     console.log('===============================================');
     console.log(`Running: ${taskName} ${action ? action : ''} ${JSON.stringify(args)}`);
     console.log('===============================================');
@@ -92,7 +160,7 @@ runner.setHandler(async (data) => {
         const commandsWithDescriptor = ['task:create', 'task:remove', 'task:publish', 'task:describe', 'task:fingerprint'];
         const commandsWithRunner = ['runner:create', 'runner:remove'];
         const commandsWithoutParams = ['project:unlink', 'project:sync', 'auth:clear'];
-        const silentCommands = ['task:describe', 'task:list', 'auth:list', 'info'];
+        const silentCommands = ['task:describe', 'task:list', 'auth:list', 'info', 'docs:download'];
         if (commandsWithDescriptor.includes(taskName)) {
             result = await task.run({ descriptorName: action });
         }
@@ -170,9 +238,9 @@ runner.setHandler(async (data) => {
             });
         }
         else if (taskName === 'project:create') {
-            const { projectName, description } = args;
+            const { name, description } = args;
             result = await task.run({
-                projectName,
+                name,
                 description
             });
         }

package/dist/tasks/auth/add.d.ts

@@ -5,7 +5,7 @@ export declare const add: import("@forgehive/task").TaskInstanceType<(argv: {
     apiSecret: string;
     url: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
     fetchMeInfo: (apiKey: string, apiSecret: string, url: string) => Promise<{
         success: boolean;
@@ -20,7 +20,7 @@ export declare const add: import("@forgehive/task").TaskInstanceType<(argv: {
     teamName: string | undefined;
     userName: string | undefined;
 }>, {
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
     fetchMeInfo: (apiKey: string, apiSecret: string, url: string) => Promise<{
         success: boolean;

package/dist/tasks/auth/add.js

@@ -14,10 +14,10 @@ const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const load_1 = require("./load");
 const schema = new schema_1.Schema({
-    name: schema_1.Schema.string(),
-    apiKey: schema_1.Schema.string(),
-    apiSecret: schema_1.Schema.string(),
-    url: schema_1.Schema.string()
+    name: schema_1.Schema.string().describe('The name of the profile'),
+    apiKey: schema_1.Schema.string().describe('The API key for the profile'),
+    apiSecret: schema_1.Schema.string().describe('The API secret for the profile'),
+    url: schema_1.Schema.string().describe('The URL for the profile')
 });
 const boundaries = {
     loadProfiles: load_1.load.asBoundary(),

package/dist/tasks/auth/clear.d.ts

@@ -1,6 +1,6 @@
 import { type Profiles } from '../types';
-export declare const clear: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+export declare const clear: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
     clearProfiles: () => Promise<void>;
 }>) => Promise<{
     status: string;
@@ -11,6 +11,6 @@ export declare const clear: import("@forgehive/task").TaskInstanceType<(argv: {}
     message: string;
     clearedCount: number;
 }>, {
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
     clearProfiles: () => Promise<void>;
 }>;

package/dist/tasks/auth/list.d.ts

@@ -1,6 +1,6 @@
 import { type Profiles } from '../types';
-export declare const list: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+export declare const list: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
 }>) => Promise<{
     status: string;
     profiles: never[];
@@ -16,5 +16,5 @@ export declare const list: import("@forgehive/task").TaskInstanceType<(argv: {},
     }[];
     status?: undefined;
 }>, {
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
 }>;

package/dist/tasks/auth/load.d.ts

@@ -1,5 +1,5 @@
 import { type Profiles } from '../types';
-export declare const load: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+export declare const load: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
     ensureBuildsFolder: () => Promise<string>;
 }>) => Promise<Profiles>, {
     ensureBuildsFolder: () => Promise<string>;

package/dist/tasks/auth/loadCurrent.d.ts

@@ -1,6 +1,6 @@
 import { type Profile } from '../types';
-export declare const loadCurrent: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadProfiles: (args: {}) => Promise<Promise<import("../types").Profiles>>;
+export declare const loadCurrent: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<import("../types").Profiles>>;
 }>) => Promise<Profile>, {
-    loadProfiles: (args: {}) => Promise<Promise<import("../types").Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<import("../types").Profiles>>;
 }>;

package/dist/tasks/auth/remove.d.ts

@@ -2,12 +2,12 @@ import { type Profiles } from '../types';
 export declare const remove: import("@forgehive/task").TaskInstanceType<(argv: {
     profileName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
 }>) => Promise<{
     status: string;
     message: string;
 }>, {
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
 }>;

package/dist/tasks/auth/remove.js

@@ -14,7 +14,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const load_1 = require("./load");
 const schema = new schema_1.Schema({
-    profileName: schema_1.Schema.string()
+    profileName: schema_1.Schema.string().describe('The name of the auth profile to remove')
 });
 const boundaries = {
     loadProfiles: load_1.load.asBoundary(),

package/dist/tasks/auth/switch.d.ts

@@ -2,11 +2,11 @@ import { type Profiles } from '../types';
 export declare const switchProfile: import("@forgehive/task").TaskInstanceType<(argv: {
     profileName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
 }>) => Promise<{
     default: string;
 }>, {
-    loadProfiles: (args: {}) => Promise<Promise<Profiles>>;
+    loadProfiles: (args: Record<string, unknown>) => Promise<Promise<Profiles>>;
     persistProfiles: (profiles: Profiles) => Promise<void>;
 }>;

package/dist/tasks/auth/switch.js

@@ -14,7 +14,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const load_1 = require("./load");
 const schema = new schema_1.Schema({
-    profileName: schema_1.Schema.string()
+    profileName: schema_1.Schema.string().describe('The name of the auth profile to switch to')
 });
 const boundaries = {
     loadProfiles: load_1.load.asBoundary(),

package/dist/tasks/bundle/create.d.ts

@@ -3,9 +3,9 @@ export declare const create: import("@forgehive/task").TaskInstanceType<(argv: {
     entryPoint: string;
     outputFile: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
 }>) => Promise<{
     outputFile: string;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
 }>;

package/dist/tasks/bundle/create.js

@@ -12,8 +12,8 @@ const schema_1 = require("@forgehive/schema");
 const esbuild_1 = __importDefault(require("esbuild"));
 const load_1 = require("../conf/load");
 const schema = new schema_1.Schema({
-    entryPoint: schema_1.Schema.string(),
-    outputFile: schema_1.Schema.string()
+    entryPoint: schema_1.Schema.string().describe('Path to the task entry point file'),
+    outputFile: schema_1.Schema.string().describe('Path for the bundled output file')
 });
 const boundaries = {
     loadConf: load_1.load.asBoundary()

package/dist/tasks/bundle/fingerprint.d.ts

@@ -4,7 +4,7 @@ export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(ar
     filePath?: string | undefined;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     getCwd: () => Promise<string>;
-    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
     readFile: (filePath: string) => Promise<string>;
     writeFile: (filePath: string, content: string) => Promise<void>;
     ensureFingerprintsFolder: (cwd: string, conf: {
@@ -35,7 +35,7 @@ export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(ar
     fingerprintFile?: undefined;
 }>, {
     getCwd: () => Promise<string>;
-    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
     readFile: (filePath: string) => Promise<string>;
     writeFile: (filePath: string, content: string) => Promise<void>;
     ensureFingerprintsFolder: (cwd: string, conf: {

package/dist/tasks/bundle/fingerprint.js

@@ -16,8 +16,8 @@ const load_1 = require("../conf/load");
 const taskAnalysis_1 = require("../../utils/taskAnalysis");
 const description = 'Generate task bundle with comprehensive fingerprinting and type extraction';
 const schema = new schema_1.Schema({
-    descriptorName: schema_1.Schema.string(),
-    filePath: schema_1.Schema.string().optional()
+    descriptorName: schema_1.Schema.string().describe('The task descriptor name (e.g. domain:taskName)'),
+    filePath: schema_1.Schema.string().describe('Optional path to the task source file').optional()
 });
 const boundaries = {
     getCwd: async () => {

package/dist/tasks/bundle/load.js

@@ -40,7 +40,7 @@ exports.load = void 0;
 const task_1 = require("@forgehive/task");
 const schema_1 = require("@forgehive/schema");
 const schema = new schema_1.Schema({
-    bundlePath: schema_1.Schema.string()
+    bundlePath: schema_1.Schema.string().describe('Path to the bundle file to load')
 });
 const boundaries = {};
 exports.load = (0, task_1.createTask)({

package/dist/tasks/bundle/zip.js

@@ -14,10 +14,10 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const description = 'Zip a bundle file for distribution';
 const schema = new schema_1.Schema({
-    dir: schema_1.Schema.string(),
-    input: schema_1.Schema.string(),
-    output: schema_1.Schema.string(),
-    forgeJsonPath: schema_1.Schema.string().optional() // Optional path to forge.json - if provided, it will be included
+    dir: schema_1.Schema.string().describe('Directory that will contain the generated zip'),
+    input: schema_1.Schema.string().describe('Path to the file or folder to add to the zip'),
+    output: schema_1.Schema.string().describe('Output path for the generated zip file'),
+    forgeJsonPath: schema_1.Schema.string().describe('Optional path to forge.json to include in the bundle').optional() // Optional path to forge.json - if provided, it will be included
 });
 const boundaries = {
     createWriteStream: async (outputPath) => {

package/dist/tasks/conf/info.d.ts

@@ -1,7 +1,7 @@
-export declare const info: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+export declare const info: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
     readFile: (filePath: string) => Promise<string>;
-    loadConfig: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
+    loadConfig: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<import("../types").Profile>>;
 }>) => Promise<{
     version: any;
     profile: null;
@@ -22,6 +22,6 @@ export declare const info: import("@forgehive/task").TaskInstanceType<(argv: {},
     error?: undefined;
 }>, {
     readFile: (filePath: string) => Promise<string>;
-    loadConfig: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
+    loadConfig: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<import("../types").Profile>>;
 }>;

package/dist/tasks/conf/load.d.ts

@@ -1,5 +1,5 @@
 import { type ForgeConf } from '../types';
-export declare const load: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+export declare const load: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
     readFile: (filePath: string) => Promise<string>;
 }>) => Promise<ForgeConf>, {
     readFile: (filePath: string) => Promise<string>;

package/dist/tasks/docs/download.js

@@ -51,8 +51,8 @@ const description = 'Download ForgeHive LLM guides from GitHub to local project'
 const LLM_GUIDE_URL = 'https://raw.githubusercontent.com/forge-and-hive/forge-mono-repo/refs/heads/main/docs/llm.md';
 const LLM_HIVE_LOGGING_URL = 'https://raw.githubusercontent.com/forge-and-hive/forge-mono-repo/refs/heads/main/docs/llm-hive-logging.md';
 const schema = new schema_1.Schema({
-    path: schema_1.Schema.string().optional(),
-    logs: schema_1.Schema.boolean().optional()
+    path: schema_1.Schema.string().describe('Optional output path for the downloaded docs').optional(),
+    logs: schema_1.Schema.boolean().describe('Include execution logs in the downloaded docs').optional()
 });
 const boundaries = {
     fetchFile: async (url) => {
@@ -117,6 +117,7 @@ exports.download = (0, task_1.createTask)({
         });
         // Download Hive logging guide if --logs flag is provided
         if (logs) {
+            console.log('===============================================');
             const logsTargetPath = customPath
                 ? path_1.default.join(path_1.default.dirname(customPath), 'hive-logging.md')
                 : 'docs/hive-logging.md';
@@ -142,6 +143,7 @@ exports.download = (0, task_1.createTask)({
                 size: logsContent.length
             });
         }
+        console.log('===============================================');
         return {
             success: true,
             downloads: results,

package/dist/tasks/fixture/download.d.ts

@@ -11,8 +11,8 @@ interface FixtureResponse {
 export declare const download: import("@forgehive/task").TaskInstanceType<(argv: {
     uuid: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
-    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
     downloadFixture: (uuid: string, profile: Profile) => Promise<FixtureResponse>;
     getCwd: () => Promise<string>;
     persistFixture: (filePath: string, data: FixtureData) => Promise<{
@@ -23,8 +23,8 @@ export declare const download: import("@forgehive/task").TaskInstanceType<(argv:
     path: string;
     shortPath: string;
 }>, {
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
-    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<import("../types").ForgeConf>>;
     downloadFixture: (uuid: string, profile: Profile) => Promise<FixtureResponse>;
     getCwd: () => Promise<string>;
     persistFixture: (filePath: string, data: FixtureData) => Promise<{

package/dist/tasks/fixture/download.js

@@ -16,7 +16,7 @@ const loadCurrent_1 = require("../auth/loadCurrent");
 const load_1 = require("../conf/load");
 const description = 'Download a fixture by UUID to a path based on task descriptor returned from API';
 const schema = new schema_1.Schema({
-    uuid: schema_1.Schema.string()
+    uuid: schema_1.Schema.string().describe('The UUID of the fixture to download')
 });
 const boundaries = {
     loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),

package/dist/tasks/init.js

@@ -9,7 +9,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const task_1 = require("@forgehive/task");
 const schema_1 = require("@forgehive/schema");
 const schema = new schema_1.Schema({
-    dryRun: schema_1.Schema.boolean().optional()
+    dryRun: schema_1.Schema.boolean().describe('Preview the changes without writing any files').optional()
 });
 const boundaries = {
     saveFile: async (path, content) => {

package/dist/tasks/project/create.d.ts

@@ -1,10 +1,10 @@
 import { type ForgeConf, type Profile } from '../types';
 export declare const create: import("@forgehive/task").TaskInstanceType<(argv: {
+    name: string;
     description?: string | undefined;
-    projectName?: string | undefined;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     writeFile: (filePath: string, content: string) => Promise<void>;
     createProject: (profile: Profile, payload: {
         projectName: string;
@@ -16,8 +16,8 @@ export declare const create: import("@forgehive/task").TaskInstanceType<(argv: {
     project: any;
     localUuid: string;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     writeFile: (filePath: string, content: string) => Promise<void>;
     createProject: (profile: Profile, payload: {
         projectName: string;

package/dist/tasks/project/create.js

@@ -14,11 +14,11 @@ const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const load_1 = require("../conf/load");
 const loadCurrent_1 = require("../auth/loadCurrent");
-const name = 'project:create';
-const description = 'Create a new project in ForgeHive';
+const taskName = 'project:create';
+const taskDescription = 'Create a new project in ForgeHive';
 const schema = new schema_1.Schema({
-    projectName: schema_1.Schema.string().optional(),
-    description: schema_1.Schema.string().optional()
+    name: schema_1.Schema.string().describe('The name of the project'),
+    description: schema_1.Schema.string().describe('Optional description of the project').optional()
 });
 const boundaries = {
     loadConf: load_1.load.asBoundary(),
@@ -39,33 +39,29 @@ const boundaries = {
     }
 };
 exports.create = (0, task_1.createTask)({
-    name,
-    description,
+    name: taskName,
+    description: taskDescription,
     schema,
     boundaries,
     fn: async function (argv, { loadConf, loadCurrentProfile, writeFile, createProject }) {
-        const { projectName: inputProjectName, description } = argv;
+        const { name: projectName, 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 = (0, uuid_1.v4)();
-            // Update forge.json with the new UUID
-            const forgePath = path_1.default.join(process.cwd(), 'forge.json');
-            const updatedConf = {
-                ...conf,
-                project: {
-                    ...conf.project,
-                    uuid: projectUuid
-                }
-            };
-            await writeFile(forgePath, JSON.stringify(updatedConf, null, 2));
+        const projectUuid = conf.project.uuid || (0, uuid_1.v4)();
+        // Update forge.json with the project name and UUID
+        const forgePath = path_1.default.join(process.cwd(), 'forge.json');
+        const updatedConf = {
+            ...conf,
+            project: {
+                ...conf.project,
+                name: projectName,
+                uuid: projectUuid
+            }
+        };
+        await writeFile(forgePath, JSON.stringify(updatedConf, null, 2));
+        console.log(`Updated forge.json with project name: ${projectName}`);
+        if (!conf.project.uuid) {
             console.log(`Generated and saved project UUID: ${projectUuid}`);
         }
         // Load current profile for API authentication

package/dist/tasks/project/link.d.ts

@@ -2,8 +2,8 @@ import { type ForgeConf, type Profile } from '../types';
 export declare const link: import("@forgehive/task").TaskInstanceType<(argv: {
     uuid: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     writeFile: (filePath: string, content: string) => Promise<void>;
     fetchProject: (profile: Profile, uuid: string) => Promise<Response>;
 }>) => Promise<{
@@ -15,8 +15,8 @@ export declare const link: import("@forgehive/task").TaskInstanceType<(argv: {
         tasksCount: any;
     };
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<Profile>>;
     writeFile: (filePath: string, content: string) => Promise<void>;
     fetchProject: (profile: Profile, uuid: string) => Promise<Response>;
 }>;

package/dist/tasks/project/link.js

@@ -16,7 +16,7 @@ const loadCurrent_1 = require("../auth/loadCurrent");
 const name = 'project:link';
 const description = 'Link an existing remote project to the local project by UUID';
 const schema = new schema_1.Schema({
-    uuid: schema_1.Schema.string()
+    uuid: schema_1.Schema.string().describe('The UUID of the project to link')
 });
 const boundaries = {
     loadConf: load_1.load.asBoundary(),

package/dist/tasks/project/sync.d.ts

@@ -1,10 +1,10 @@
 import { type ForgeConf } from '../types';
-export declare const sync: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
+export declare const sync: import("@forgehive/task").TaskInstanceType<(argv: Record<string, unknown>, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<import("../types").Profile>>;
     getCwd: () => Promise<string>;
     persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
-    syncTasksToHive: (projectUuid: string, tasks: Array<{
+    syncTasksToHive: (projectUuid: string, projectName: string, projectDescription: string | undefined, tasks: Array<{
         uuid: string;
         name: string;
     }>, apiKey: string, apiSecret: string, baseUrl: string) => Promise<{
@@ -74,11 +74,11 @@ export declare const sync: import("@forgehive/task").TaskInstanceType<(argv: {},
     projectUrl: string;
     message?: undefined;
 }>, {
-    loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
-    loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
+    loadConf: (args: Record<string, unknown>) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: Record<string, unknown>) => Promise<Promise<import("../types").Profile>>;
     getCwd: () => Promise<string>;
     persistConf: (forge: ForgeConf, cwd: string) => Promise<void>;
-    syncTasksToHive: (projectUuid: string, tasks: Array<{
+    syncTasksToHive: (projectUuid: string, projectName: string, projectDescription: string | undefined, tasks: Array<{
         uuid: string;
         name: string;
     }>, apiKey: string, apiSecret: string, baseUrl: string) => Promise<{

package/dist/tasks/project/sync.js

@@ -25,7 +25,7 @@ const boundaries = {
         const forgePath = path_1.default.join(cwd, 'forge.json');
         await promises_1.default.writeFile(forgePath, JSON.stringify(forge, null, 2));
     },
-    syncTasksToHive: async (projectUuid, tasks, apiKey, apiSecret, baseUrl) => {
+    syncTasksToHive: async (projectUuid, projectName, projectDescription, tasks, apiKey, apiSecret, baseUrl) => {
         try {
             const url = `${baseUrl}/api/projects/${projectUuid}/sync`;
             const response = await fetch(url, {
@@ -34,7 +34,7 @@ const boundaries = {
                     'Content-Type': 'application/json',
                     'Authorization': `Bearer ${apiKey}:${apiSecret}`
                 },
-                body: JSON.stringify({ tasks })
+                body: JSON.stringify({ projectName, description: projectDescription, tasks })
             });
             if (response.ok) {
                 const data = await response.json();
@@ -96,9 +96,13 @@ exports.sync = (0, task_1.createTask)({
             return { status: 'no-tasks', message: 'No tasks found in project' };
         }
         console.log(`  📊 Found ${tasksToSync.length} tasks to sync`);
+        console.log(`  📝 Project name: ${forge.project.name}`);
+        if (forge.project.description) {
+            console.log(`  📝 Project description: ${forge.project.description}`);
+        }
         try {
             const profile = await loadCurrentProfile({});
-            const result = await syncTasksToHive(forge.project.uuid, tasksToSync, profile.apiKey, profile.apiSecret, profile.url);
+            const result = await syncTasksToHive(forge.project.uuid, forge.project.name, forge.project.description, tasksToSync, profile.apiKey, profile.apiSecret, profile.url);
             if (result.success && result.data) {
                 const { summary, results } = result.data;
                 console.log('\\n  ✅ Sync completed successfully!');