ardent-cli-beta 0.0.12 → 0.0.13

package/README.md

@@ -19,7 +19,8 @@ context is retained from login. Project listing, creation, deletion, and local
 context switching are implemented. Organization member listing, invitation,
 removal, and pending-invitation cancellation are implemented. Connector listing
 and registration are implemented; registration follows connector status, while
-credential delivery and replication readiness remain owed.
+credential delivery and replication readiness remain owed. Connector-scoped branch
+creation, deletion, listing, and local switching are implemented.
 
 Set `ARDENT_API_URL` to point the CLI at a development control plane. Without
 it, the CLI uses `https://production.tryardent.com`.
@@ -40,7 +41,25 @@ npm run build
 ./bin/run.js member delete teammate@example.com
 ./bin/run.js connector list
 ./bin/run.js connector create postgresql 'postgresql://user:password@database.example.com/app'
+./bin/run.js branch create "my feature"
+./bin/run.js branch list
+./bin/run.js branch switch "my feature"
+./bin/run.js branch delete "my feature"
 ARDENT_API_URL=http://localhost:8080 ./bin/run.js login --token <token>
 ```
 
+Branch commands operate on a connector. When discovering connectors, the CLI uses
+its project context; one connector is selected automatically. In an interactive
+terminal, multiple connectors appear in a numbered picker with the saved connector
+as the default. Automation uses the saved connector and fails if selection is
+ambiguous. Project changes clear connector and branch context.
+
+Creation uses the connector's latest published snapshot. If that snapshot is
+unavailable, creation fails without choosing an older one. Names are unique within
+a connector while the branch is not deleted. `branch delete` sends the connector
+and name to the API, which resolves the target. `branch list` fetches current state
+and marks the locally selected branch with `*`; `branch switch` changes local
+context. Create and delete follow the operation in an interactive terminal;
+non-interactive commands and `--json` return the accepted operation immediately.
+
 Before changing this repository, read [ARDENT_CLI_DEVELOPMENT.md](ARDENT_CLI_DEVELOPMENT.md).

package/dist/auth/credentials.d.ts

@@ -5,8 +5,22 @@ export interface Session {
     };
     projects?: ProjectIdentity[];
     selectedProject?: ProjectIdentity;
+    connectors?: ConnectorIdentity[];
+    selectedConnector?: ConnectorIdentity;
+    branches?: BranchIdentity[];
+    selectedBranch?: BranchIdentity;
     token: string;
 }
+export interface ConnectorIdentity {
+    id: string;
+    name: string;
+    project_id: string;
+}
+export interface BranchIdentity {
+    id: string;
+    name: string;
+    connector_id: string;
+}
 export interface ProjectIdentity {
     id: string;
     name: string;

package/dist/auth/credentials.js

@@ -17,7 +17,7 @@ export async function loadSession(directory) {
         if (typeof session.token !== 'string' || session.token.length === 0)
             throw new Error();
         if (session.organization === undefined) {
-            if (session.projects !== undefined || session.selectedProject !== undefined)
+            if (session.projects !== undefined || session.selectedProject !== undefined || session.connectors !== undefined || session.selectedConnector !== undefined || session.branches !== undefined || session.selectedBranch !== undefined)
                 throw new Error();
             return { token: session.token };
         }
@@ -47,7 +47,43 @@ export async function loadSession(directory) {
             if (!selectedProject)
                 throw new Error();
         }
+        let connectors;
+        if (session.connectors !== undefined) {
+            if (!selectedProject || !Array.isArray(session.connectors) || session.connectors.some((connector) => !isProjectIdentity(connector) || connector.project_id !== selectedProject.id))
+                throw new Error();
+            connectors = session.connectors.map(({ id, name, project_id }) => ({ id, name, project_id }));
+            if (new Set(connectors.map(({ id }) => id)).size !== connectors.length || new Set(connectors.map(({ name }) => name)).size !== connectors.length)
+                throw new Error();
+        }
+        let selectedConnector;
+        if (session.selectedConnector !== undefined) {
+            if (!isProjectIdentity(session.selectedConnector) || !connectors)
+                throw new Error();
+            selectedConnector = connectors.find(({ id, name, project_id }) => id === session.selectedConnector?.id && name === session.selectedConnector.name && project_id === session.selectedConnector.project_id);
+            if (!selectedConnector)
+                throw new Error();
+        }
+        let branches;
+        if (session.branches !== undefined) {
+            if (!selectedConnector || !Array.isArray(session.branches) || session.branches.some((branch) => !isProjectIdentity(branch) || branch.connector_id !== selectedConnector.id))
+                throw new Error();
+            branches = session.branches.map(({ id, name, connector_id }) => ({ id, name, connector_id }));
+            if (new Set(branches.map(({ id }) => id)).size !== branches.length || new Set(branches.map(({ name }) => name)).size !== branches.length)
+                throw new Error();
+        }
+        let selectedBranch;
+        if (session.selectedBranch !== undefined) {
+            if (!isProjectIdentity(session.selectedBranch) || !branches)
+                throw new Error();
+            selectedBranch = branches.find(({ id, name, connector_id }) => id === session.selectedBranch?.id && name === session.selectedBranch.name && connector_id === session.selectedBranch.connector_id);
+            if (!selectedBranch)
+                throw new Error();
+        }
         return {
+            ...(connectors === undefined ? {} : { connectors }),
+            ...(selectedConnector === undefined ? {} : { selectedConnector }),
+            ...(branches === undefined ? {} : { branches }),
+            ...(selectedBranch === undefined ? {} : { selectedBranch }),
             organization: session.organization,
             ...(projects === undefined ? {} : { projects }),
             ...(selectedProject === undefined ? {} : { selectedProject }),

package/dist/branches/client.d.ts

@@ -0,0 +1,19 @@
+export interface Branch {
+    id: string;
+    connector_id: string;
+    name: string;
+    state: string;
+    failure_reason?: string;
+}
+export interface BranchOperation {
+    branch: Branch;
+    operation: {
+        operation_id: string;
+        workflow_id: string;
+    };
+}
+export declare function listBranches(token: string, connectorID: string): Promise<Branch[]>;
+export declare function createBranch(token: string, connectorID: string, name: string): Promise<BranchOperation>;
+export declare function deleteBranch(token: string, connectorID: string, name: string): Promise<BranchOperation>;
+export declare function waitForBranchOperation(token: string, workflowID: string, onStatus?: (status: string) => void): Promise<void>;
+export declare function branchName(arguments_: unknown[]): string;

package/dist/branches/client.js

@@ -0,0 +1,60 @@
+import { randomUUID } from 'node:crypto';
+import { request } from '../api/client.js';
+export async function listBranches(token, connectorID) {
+    const branches = await request(token, `/branches?${new URLSearchParams({ connector_id: connectorID })}`);
+    if (!Array.isArray(branches) || branches.some((branch) => !isBranch(branch, connectorID)) || new Set(branches.map(({ id }) => id)).size !== branches.length || new Set(branches.map(({ name }) => name)).size !== branches.length) {
+        throw new Error('Ardent API returned an invalid branches response.');
+    }
+    return branches;
+}
+export async function createBranch(token, connectorID, name) {
+    const result = await request(token, '/branches', {
+        method: 'POST', body: JSON.stringify({ connector_id: connectorID, name, request_id: randomUUID() }),
+    });
+    validateOperation(result, connectorID, name);
+    return result;
+}
+export async function deleteBranch(token, connectorID, name) {
+    const result = await request(token, '/branches', {
+        method: 'DELETE', body: JSON.stringify({ connector_id: connectorID, name }),
+    });
+    validateOperation(result, connectorID, name);
+    return result;
+}
+export async function waitForBranchOperation(token, workflowID, onStatus) {
+    const deadline = Date.now() + 30 * 60 * 1000;
+    while (Date.now() < deadline) {
+        const result = await request(token, `/workflows/${encodeURIComponent(workflowID)}`);
+        if (!result || result.id !== workflowID || !['DELAYED', 'ENQUEUED', 'PENDING', 'SUCCESS', 'ERROR', 'CANCELLED', 'MAX_RECOVERY_ATTEMPTS_EXCEEDED'].includes(result.status) || (result.failure !== undefined && typeof result.failure !== 'string')) {
+            throw new Error('Ardent API returned an invalid branch operation status.');
+        }
+        onStatus?.(result.status.toLowerCase());
+        if (result.status === 'SUCCESS')
+            return;
+        if (!['DELAYED', 'ENQUEUED', 'PENDING'].includes(result.status))
+            throw new Error(result.failure || `Branch operation ${result.status.toLowerCase()}.`);
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+    throw new Error('Timed out waiting for the branch operation. Run ardent-beta branch list to check its state.');
+}
+export function branchName(arguments_) {
+    const name = arguments_.map(String).join(' ').trim();
+    if (!name || [...name].length > 128 || /[\p{Cc}]/u.test(name))
+        throw new Error('Branch name must contain 1 to 128 characters without control characters.');
+    return name;
+}
+function isBranch(value, connectorID) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const branch = value;
+    return typeof branch.id === 'string' && branch.id.length > 0 && branch.connector_id === connectorID &&
+        typeof branch.name === 'string' && branch.name.length > 0 && typeof branch.state === 'string' && branch.state.length > 0 &&
+        (branch.failure_reason === undefined || typeof branch.failure_reason === 'string');
+}
+function validateOperation(result, connectorID, name) {
+    if (!result || !isBranch(result.branch, connectorID) || result.branch.name !== name || !result.operation ||
+        typeof result.operation.operation_id !== 'string' || !result.operation.operation_id ||
+        typeof result.operation.workflow_id !== 'string' || !result.operation.workflow_id) {
+        throw new Error('Ardent API returned an invalid branch operation response.');
+    }
+}

package/dist/branches/context.d.ts

@@ -0,0 +1,2 @@
+import { type BranchIdentity, type Session } from '../auth/credentials.js';
+export declare function replaceBranchCache(directory: string, session: Session, branches: BranchIdentity[]): Promise<Session>;

package/dist/branches/context.js

@@ -0,0 +1,10 @@
+import { saveSession } from '../auth/credentials.js';
+export async function replaceBranchCache(directory, session, branches) {
+    const identities = branches.map(({ id, name, connector_id }) => ({ id, name, connector_id }));
+    const selectedBranch = identities.find(({ id }) => id === session.selectedBranch?.id);
+    const updated = { ...session, branches: identities, selectedBranch };
+    if (!selectedBranch)
+        delete updated.selectedBranch;
+    await saveSession(directory, updated);
+    return updated;
+}

package/dist/commands/branch/create.d.ts

@@ -0,0 +1,11 @@
+import { ArdentCommand } from '../../command.js';
+import { type BranchOperation } from '../../branches/client.js';
+export default class BranchCreate extends ArdentCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static strict: boolean;
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<BranchOperation>;
+}

package/dist/commands/branch/create.js

@@ -0,0 +1,39 @@
+import { Args, ux } from '@oclif/core';
+import { ArdentCommand } from '../../command.js';
+import { branchName, createBranch, waitForBranchOperation } from '../../branches/client.js';
+import { replaceBranchCache } from '../../branches/context.js';
+import { requireConnector } from '../../connectors/context.js';
+import { terminalText } from '../../terminal.js';
+export default class BranchCreate extends ArdentCommand {
+    static args = { name: Args.string({ description: 'Branch name', required: true }) };
+    static strict = false;
+    static description = 'Create a branch in the selected connector';
+    static helpGroup = 'Branches';
+    async run() {
+        const { argv } = await this.parse(BranchCreate);
+        const name = branchName(argv);
+        const session = await requireConnector(this.config.configDir, !this.jsonEnabled());
+        const interactive = !this.jsonEnabled() && ux.action.type === 'spinner';
+        const target = `${terminalText(name)} in connector ${terminalText(session.selectedConnector.name)}`;
+        if (interactive)
+            ux.action.start(`Creating branch ${target}`);
+        else if (!this.jsonEnabled())
+            this.log(`Creating branch ${target}...`);
+        try {
+            const result = await createBranch(session.token, session.selectedConnector.id, name);
+            await replaceBranchCache(this.config.configDir, session, [...(session.branches ?? []).filter(({ id, name }) => id !== result.branch.id && name !== result.branch.name), result.branch]);
+            if (interactive) {
+                await waitForBranchOperation(session.token, result.operation.workflow_id, (status) => { ux.action.status = status; });
+                ux.action.stop(ux.colorize('green', '✓ created'));
+            }
+            else if (!this.jsonEnabled())
+                this.log(`Branch creation started (${terminalText(result.branch.id)}).`);
+            return result;
+        }
+        catch (error) {
+            if (interactive)
+                ux.action.stop('failed');
+            throw error;
+        }
+    }
+}

package/dist/commands/branch/delete.d.ts

@@ -0,0 +1,11 @@
+import { ArdentCommand } from '../../command.js';
+import { type BranchOperation } from '../../branches/client.js';
+export default class BranchDelete extends ArdentCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static strict: boolean;
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<BranchOperation>;
+}

package/dist/commands/branch/delete.js

@@ -0,0 +1,39 @@
+import { Args, ux } from '@oclif/core';
+import { ArdentCommand } from '../../command.js';
+import { branchName, deleteBranch, waitForBranchOperation } from '../../branches/client.js';
+import { replaceBranchCache } from '../../branches/context.js';
+import { requireConnector } from '../../connectors/context.js';
+import { terminalText } from '../../terminal.js';
+export default class BranchDelete extends ArdentCommand {
+    static args = { name: Args.string({ description: 'Branch name', required: true }) };
+    static strict = false;
+    static description = 'Delete a branch in the selected connector';
+    static helpGroup = 'Branches';
+    async run() {
+        const { argv } = await this.parse(BranchDelete);
+        const name = branchName(argv);
+        const session = await requireConnector(this.config.configDir, !this.jsonEnabled());
+        const interactive = !this.jsonEnabled() && ux.action.type === 'spinner';
+        const target = `${terminalText(name)} in connector ${terminalText(session.selectedConnector.name)}`;
+        if (interactive)
+            ux.action.start(`Deleting branch ${target}`);
+        else if (!this.jsonEnabled())
+            this.log(`Deleting branch ${target}...`);
+        try {
+            const result = await deleteBranch(session.token, session.selectedConnector.id, name);
+            if (interactive) {
+                await waitForBranchOperation(session.token, result.operation.workflow_id, (status) => { ux.action.status = status; });
+                await replaceBranchCache(this.config.configDir, session, (session.branches ?? []).filter(({ id }) => id !== result.branch.id));
+                ux.action.stop(ux.colorize('green', '✓ deleted'));
+            }
+            else if (!this.jsonEnabled())
+                this.log(`Branch deletion started (${terminalText(result.branch.id)}).`);
+            return result;
+        }
+        catch (error) {
+            if (interactive)
+                ux.action.stop('failed');
+            throw error;
+        }
+    }
+}

package/dist/commands/branch/list.d.ts

@@ -0,0 +1,9 @@
+import { ArdentCommand } from '../../command.js';
+import { type Branch } from '../../branches/client.js';
+export default class BranchList extends ArdentCommand {
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<{
+        branches: Branch[];
+    }>;
+}

package/dist/commands/branch/list.js

@@ -0,0 +1,22 @@
+import { ArdentCommand } from '../../command.js';
+import { listBranches } from '../../branches/client.js';
+import { replaceBranchCache } from '../../branches/context.js';
+import { requireConnector } from '../../connectors/context.js';
+import { terminalText } from '../../terminal.js';
+export default class BranchList extends ArdentCommand {
+    static description = 'List branches in the selected connector';
+    static helpGroup = 'Branches';
+    async run() {
+        const session = await requireConnector(this.config.configDir, !this.jsonEnabled());
+        const branches = await listBranches(session.token, session.selectedConnector.id);
+        const updated = await replaceBranchCache(this.config.configDir, session, branches);
+        if (!this.jsonEnabled()) {
+            if (branches.length === 0)
+                this.log('No branches found.');
+            const width = Math.max(0, ...branches.map(({ name }) => terminalText(name).length));
+            for (const branch of branches)
+                this.log(`${branch.id === updated.selectedBranch?.id ? '*' : ' '} ${terminalText(branch.name).padEnd(width)}  ${terminalText(branch.state)}`);
+        }
+        return { branches };
+    }
+}

package/dist/commands/branch/switch.d.ts

@@ -0,0 +1,11 @@
+import { ArdentCommand } from '../../command.js';
+import { type Branch } from '../../branches/client.js';
+export default class BranchSwitch extends ArdentCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static strict: boolean;
+    static description: string;
+    static helpGroup: string;
+    run(): Promise<Branch>;
+}

package/dist/commands/branch/switch.js

@@ -0,0 +1,27 @@
+import { Args } from '@oclif/core';
+import { saveSession } from '../../auth/credentials.js';
+import { ArdentCommand } from '../../command.js';
+import { branchName, listBranches } from '../../branches/client.js';
+import { replaceBranchCache } from '../../branches/context.js';
+import { requireConnector } from '../../connectors/context.js';
+import { terminalText } from '../../terminal.js';
+export default class BranchSwitch extends ArdentCommand {
+    static args = { name: Args.string({ description: 'Branch name', required: true }) };
+    static strict = false;
+    static description = 'Switch to a branch in the selected connector';
+    static helpGroup = 'Branches';
+    async run() {
+        const { argv } = await this.parse(BranchSwitch);
+        const name = branchName(argv);
+        const session = await requireConnector(this.config.configDir, !this.jsonEnabled());
+        const branches = await listBranches(session.token, session.selectedConnector.id);
+        const updated = await replaceBranchCache(this.config.configDir, session, branches);
+        const branch = branches.find((candidate) => candidate.name === name);
+        if (!branch)
+            this.error(`Branch ${JSON.stringify(name)} not found in connector ${JSON.stringify(session.selectedConnector.name)}.`);
+        await saveSession(this.config.configDir, { ...updated, selectedBranch: { id: branch.id, name: branch.name, connector_id: branch.connector_id } });
+        if (!this.jsonEnabled())
+            this.log(`✓ Switched to branch ${terminalText(name)} in connector ${terminalText(session.selectedConnector.name)}`);
+        return branch;
+    }
+}

package/dist/commands/connector/list.js

@@ -1,6 +1,7 @@
 import { loadSession } from '../../auth/credentials.js';
 import { ArdentCommand } from '../../command.js';
 import { listConnectors } from '../../connectors/client.js';
+import { replaceConnectorCache } from '../../connectors/context.js';
 import { terminalText } from '../../terminal.js';
 export default class ConnectorList extends ArdentCommand {
     static description = 'List connectors in the selected project';
@@ -12,6 +13,7 @@ export default class ConnectorList extends ArdentCommand {
         if (!session.selectedProject)
             this.error('No project selected. Run ardent-beta project list, then ardent-beta project switch <name>.');
         const connectors = await listConnectors(session.token, session.organization.id, session.selectedProject.id);
+        await replaceConnectorCache(this.config.configDir, session, connectors);
         if (!this.jsonEnabled()) {
             if (connectors.length === 0)
                 this.log('No connectors found.');

package/dist/connectors/context.d.ts

@@ -0,0 +1,6 @@
+import { type ConnectorIdentity, type Session } from '../auth/credentials.js';
+export declare function replaceConnectorCache(directory: string, session: Session, connectors: ConnectorIdentity[]): Promise<Session>;
+export declare function selectConnector(directory: string, session: Session, connector: ConnectorIdentity): Promise<Session>;
+export declare function requireConnector(directory: string, interactive: boolean): Promise<Session & {
+    selectedConnector: ConnectorIdentity;
+}>;

package/dist/connectors/context.js

@@ -0,0 +1,60 @@
+import { createInterface } from 'node:readline/promises';
+import { loadSession, saveSession } from '../auth/credentials.js';
+import { terminalText } from '../terminal.js';
+import { listConnectors } from './client.js';
+export async function replaceConnectorCache(directory, session, connectors) {
+    const identities = connectors.map(({ id, name, project_id }) => ({ id, name, project_id }));
+    const selectedConnector = identities.find(({ id }) => id === session.selectedConnector?.id) ?? (identities.length === 1 ? identities[0] : undefined);
+    const updated = { ...session, connectors: identities, selectedConnector };
+    if (!selectedConnector)
+        delete updated.selectedConnector;
+    if (session.selectedConnector?.id !== selectedConnector?.id) {
+        delete updated.branches;
+        delete updated.selectedBranch;
+    }
+    await saveSession(directory, updated);
+    return updated;
+}
+export async function selectConnector(directory, session, connector) {
+    const updated = { ...session, selectedConnector: connector };
+    if (session.selectedConnector?.id !== connector.id) {
+        delete updated.branches;
+        delete updated.selectedBranch;
+    }
+    await saveSession(directory, updated);
+    return updated;
+}
+export async function requireConnector(directory, interactive) {
+    let session = await loadSession(directory);
+    if (!session?.organization)
+        throw new Error('You must be logged in to run this command. Run ardent-beta login.');
+    if (session.selectedConnector && (!interactive || !process.stdin.isTTY))
+        return { ...session, selectedConnector: session.selectedConnector };
+    if (!session.selectedProject)
+        throw new Error('No project selected for connector discovery. Run ardent-beta project list, then ardent-beta project switch <name>.');
+    const connectors = await listConnectors(session.token, session.organization.id, session.selectedProject.id);
+    session = await replaceConnectorCache(directory, session, connectors);
+    if (session.selectedConnector && connectors.length === 1)
+        return { ...session, selectedConnector: session.selectedConnector };
+    if (connectors.length === 0)
+        throw new Error('No connectors found. Run ardent-beta connector create first.');
+    if (!interactive || !process.stdin.isTTY)
+        throw new Error('No connector selected. Run this command in a terminal to select a connector first.');
+    for (const [index, connector] of connectors.entries())
+        process.stderr.write(`${index + 1}. ${terminalText(connector.name)}\n`);
+    const prompt = createInterface({ input: process.stdin, output: process.stderr });
+    let answer;
+    const current = session.selectedConnector;
+    const question = current ? `Select a connector by number [${terminalText(current.name)}]: ` : 'Select a connector by number: ';
+    try {
+        answer = (await prompt.question(question)).trim();
+    }
+    finally {
+        prompt.close();
+    }
+    const connector = !answer && current ? current : /^\d+$/.test(answer) ? connectors[Number(answer) - 1] : undefined;
+    if (!connector)
+        throw new Error('Invalid connector selection.');
+    session = await selectConnector(directory, session, connector);
+    return { ...session, selectedConnector: connector };
+}

package/dist/projects/context.js

@@ -6,6 +6,12 @@ export async function replaceProjectCache(directory, session, projects) {
     const updated = { ...session, projects: identities, selectedProject };
     if (selectedProject === undefined)
         delete updated.selectedProject;
+    if (!updated.selectedProject || session.selectedProject?.id !== updated.selectedProject.id) {
+        delete updated.connectors;
+        delete updated.selectedConnector;
+        delete updated.branches;
+        delete updated.selectedBranch;
+    }
     await saveSession(directory, updated);
     return updated;
 }
@@ -18,6 +24,12 @@ export async function selectProject(directory, session, project) {
     else
         projects[existingIndex] = selectedProject;
     const updated = { ...session, projects, selectedProject };
+    if (!updated.selectedProject || session.selectedProject?.id !== updated.selectedProject.id) {
+        delete updated.connectors;
+        delete updated.selectedConnector;
+        delete updated.branches;
+        delete updated.selectedBranch;
+    }
     await saveSession(directory, updated);
     return updated;
 }

package/oclif.manifest.json

@@ -95,6 +95,144 @@
         "status.js"
       ]
     },
+    "branch:create": {
+      "aliases": [],
+      "args": {
+        "name": {
+          "description": "Branch name",
+          "name": "name",
+          "required": true
+        }
+      },
+      "description": "Create a branch in the selected connector",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "branch:create",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": false,
+      "enableJsonFlag": true,
+      "helpGroup": "Branches",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "branch",
+        "create.js"
+      ]
+    },
+    "branch:delete": {
+      "aliases": [],
+      "args": {
+        "name": {
+          "description": "Branch name",
+          "name": "name",
+          "required": true
+        }
+      },
+      "description": "Delete a branch in the selected connector",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "branch:delete",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": false,
+      "enableJsonFlag": true,
+      "helpGroup": "Branches",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "branch",
+        "delete.js"
+      ]
+    },
+    "branch:list": {
+      "aliases": [],
+      "args": {},
+      "description": "List branches in the selected connector",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "branch:list",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "helpGroup": "Branches",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "branch",
+        "list.js"
+      ]
+    },
+    "branch:switch": {
+      "aliases": [],
+      "args": {
+        "name": {
+          "description": "Branch name",
+          "name": "name",
+          "required": true
+        }
+      },
+      "description": "Switch to a branch in the selected connector",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "branch:switch",
+      "pluginAlias": "ardent-cli-beta",
+      "pluginName": "ardent-cli-beta",
+      "pluginType": "core",
+      "strict": false,
+      "enableJsonFlag": true,
+      "helpGroup": "Branches",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "branch",
+        "switch.js"
+      ]
+    },
     "connector:create": {
       "aliases": [],
       "args": {
@@ -436,5 +574,5 @@
       ]
     }
   },
-  "version": "0.0.12"
+  "version": "0.0.13"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ardent-cli-beta",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "The Ardent command-line interface",
   "license": "Apache-2.0",
   "type": "module",