@vectorplane/ctrl-cli 0.1.11 → 0.1.12

package/dist/core/init-workspace.js

@@ -0,0 +1,73 @@
+import { ensureSessionAvailable, loadSession, upsertProfile } from "./config.js";
+import { collectGitContext } from "./git.js";
+import { collectMachineContext, collectRuntimeContext } from "./machine.js";
+import { VectorPlaneApiClient } from "./api.js";
+import { ensureFreshSession } from "./session.js";
+import { ensureAgentSetupCurrent } from "./agent-setup.js";
+import { resolveWorkspaceRoot } from "./workspace-binding.js";
+import { resolveAuthorizedWorkspace } from "./workspace-resolution.js";
+export async function buildInitLoginArgs(params) {
+    const loginArgs = [];
+    if (params.manual) {
+        loginArgs.push("--manual");
+    }
+    if (params.noBrowser) {
+        loginArgs.push("--no-browser");
+    }
+    if (params.profile) {
+        loginArgs.push("--profile", params.profile);
+    }
+    return loginArgs;
+}
+export async function runInitWorkspaceUseCase(params) {
+    let session = await loadSession(params.runtime.profile.name);
+    if (!session) {
+        params.runtime.logger.info("sessão local ausente, iniciando login...");
+        await params.ensureLoggedIn();
+        session = await ensureSessionAvailable(params.runtime.profile.name);
+    }
+    const [git, machine, runtimeContext] = await Promise.all([
+        collectGitContext(process.cwd()),
+        collectMachineContext(params.runtime.device, params.runtime.config),
+        collectRuntimeContext(params.cliVersion, "init", params.commandArgs),
+    ]);
+    const apiClient = new VectorPlaneApiClient(params.runtime.profile.apiBaseUrl, params.runtime.config.requestTimeoutMs, params.runtime.logger);
+    const freshSession = await ensureFreshSession({
+        profileName: params.runtime.profile.name,
+        session,
+        machine,
+        runtime: runtimeContext,
+        device: params.runtime.device,
+        apiClient,
+        logger: params.runtime.logger,
+    });
+    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
+    const workspace = await resolveAuthorizedWorkspace({
+        apiClient,
+        accessToken: freshSession.accessToken,
+        git,
+        explicitWorkspace: params.explicitWorkspace,
+        profile: params.runtime.profile,
+        session: freshSession,
+    });
+    const result = await ensureAgentSetupCurrent({
+        rootPath,
+        workspace,
+        repoUrl: git.remoteOrigin,
+        source: git.remoteOrigin ? "api-resolve" : "manual",
+        accessToken: freshSession.accessToken,
+        apiClient,
+        logger: params.runtime.logger,
+        explicitAgent: params.requestedAgent,
+        force: params.force,
+    });
+    await upsertProfile(params.runtime.profile.name, { workspace });
+    return {
+        workspace,
+        agent: result.agent,
+        confidence: result.confidence,
+        templatePath: result.templatePath,
+        fileStatus: result.fileStatus,
+    };
+}
+//# sourceMappingURL=init-workspace.js.map

package/dist/core/runtime-agent-setup.d.ts

@@ -0,0 +1,18 @@
+import type { VectorPlaneApiClient } from "./api.js";
+import type { Logger } from "./logger.js";
+import type { AuthSession } from "../types/auth.js";
+import type { GitContext } from "../types/workspace.js";
+export declare function ensureRuntimeAgentSetup(params: {
+    rootPath: string;
+    workspace: string;
+    git: GitContext;
+    session: AuthSession;
+    apiClient: VectorPlaneApiClient;
+    logger: Logger;
+}): Promise<{
+    agent: import("./agent-runtime-detection.js").SupportedAgent;
+    templatePath: string;
+    fileStatus: "created" | "updated" | "unchanged";
+    changed: boolean;
+    confidence: import("./agent-runtime-detection.js").DetectionConfidence;
+}>;

package/dist/core/runtime-agent-setup.js

@@ -0,0 +1,13 @@
+import { ensureAgentSetupCurrent } from "./agent-setup.js";
+export async function ensureRuntimeAgentSetup(params) {
+    return ensureAgentSetupCurrent({
+        rootPath: params.rootPath,
+        workspace: params.workspace,
+        repoUrl: params.git.remoteOrigin,
+        source: params.git.remoteOrigin ? "api-resolve" : "manual",
+        accessToken: params.session.accessToken,
+        apiClient: params.apiClient,
+        logger: params.logger,
+    });
+}
+//# sourceMappingURL=runtime-agent-setup.js.map

package/dist/core/task-runner.d.ts

@@ -0,0 +1,16 @@
+export interface LocalTaskExecutionInput {
+    execution: Record<string, unknown> | null | undefined;
+    workspaceRoot: string;
+    workspaceRef: string;
+    taskId: string;
+    stepId: string;
+    capability: string;
+}
+export declare function executeLocalTaskStep(input: LocalTaskExecutionInput): Promise<{
+    command: string;
+    args: string[];
+    cwd: string;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;

package/dist/core/task-runner.js

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { ValidationError } from "./errors.js";
+function interpolate(value, context) {
+    return value.replace(/\{([a-zA-Z0-9_]+)\}/g, (_, key) => context[key] ?? "");
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.map((item) => String(item)) : [];
+}
+export async function executeLocalTaskStep(input) {
+    const execution = input.execution ?? {};
+    const type = typeof execution.type === "string" ? execution.type : "command";
+    if (type !== "command") {
+        throw new ValidationError("A execução local do step exige `metadata.execution.type = command`.");
+    }
+    const rawCommand = typeof execution.command === "string" ? execution.command.trim() : "";
+    if (!rawCommand) {
+        throw new ValidationError("A execução local do step exige `metadata.execution.command`.");
+    }
+    const context = {
+        workspaceRoot: input.workspaceRoot,
+        workspace: input.workspaceRef,
+        taskId: input.taskId,
+        stepId: input.stepId,
+        capability: input.capability,
+    };
+    const command = interpolate(rawCommand, context);
+    const args = asStringArray(execution.args).map((item) => interpolate(item, context));
+    const cwd = typeof execution.cwd === "string" && execution.cwd.trim()
+        ? interpolate(execution.cwd, context)
+        : input.workspaceRoot;
+    const envOverrides = execution.env && typeof execution.env === "object"
+        ? Object.fromEntries(Object.entries(execution.env).map(([key, value]) => [key, interpolate(String(value), context)]))
+        : {};
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            env: { ...process.env, ...envOverrides },
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", reject);
+        child.on("close", (exitCode) => {
+            resolve({
+                command,
+                args,
+                cwd,
+                exitCode: exitCode ?? 1,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+            });
+        });
+    });
+}
+//# sourceMappingURL=task-runner.js.map

package/dist/index.js

@@ -10,9 +10,11 @@ import { runEventCommand } from "./commands/event.js";
 import { runInitCommand } from "./commands/init.js";
 import { runLoginCommand } from "./commands/login.js";
 import { runLogoutCommand } from "./commands/logout.js";
+import { runRegistryCommand } from "./commands/registry.js";
 import { runSessionCommand } from "./commands/session.js";
 import { runStatusCommand } from "./commands/status.js";
 import { runSyncCommand } from "./commands/sync.js";
+import { runTaskCommand } from "./commands/task.js";
 import { runWhoAmICommand } from "./commands/whoami.js";
 import { runWorkspaceCommand } from "./commands/workspace.js";
 import { CLIError } from "./core/errors.js";
@@ -33,6 +35,8 @@ function printHelp() {
     process.stdout.write("  logout\n");
     process.stdout.write("  sync [--force]\n");
     process.stdout.write("  status\n");
+    process.stdout.write("  task <run|templates|list|inspect|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health>\n");
+    process.stdout.write("  registry <list|register|update|deactivate>\n");
     process.stdout.write("  whoami\n");
     process.stdout.write("  doctor\n");
     process.stdout.write("  draft <create|list>\n");
@@ -60,8 +64,12 @@ export async function runCli(args) {
                 return runSyncCommand(cliVersion, rest);
             case "logout":
                 return runLogoutCommand();
+            case "registry":
+                return runRegistryCommand(rest);
             case "status":
                 return runStatusCommand();
+            case "task":
+                return runTaskCommand(cliVersion, rest);
             case "whoami":
                 return runWhoAmICommand(cliVersion);
             case "doctor":

package/dist/types/api.d.ts

@@ -66,6 +66,58 @@ export interface ResolveWorkspaceResponse {
     repoUrl?: string | null;
     [key: string]: unknown;
 }
+export type WorkspacePolicyRuleEffect = "allow" | "require_approval" | "block";
+export interface WorkspacePolicyRuleConditions {
+    archetypes?: string[];
+    minTargetPathCount?: number;
+    requiredCapabilities?: string[];
+}
+export interface WorkspacePolicyRuleRecord {
+    id: string;
+    orgId: string;
+    workspaceId: string;
+    name: string;
+    pathPrefix: string | null;
+    capability: string | null;
+    effect: WorkspacePolicyRuleEffect;
+    rationale: string | null;
+    conditions: WorkspacePolicyRuleConditions | null;
+    approvalRole: string | null;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+export interface AgentRegistryRecord {
+    id: string;
+    orgId: string | null;
+    name: string;
+    runtimeType: string;
+    provider: string;
+    model: string;
+    capabilities: string[];
+    costProfile: string;
+    latencyProfile: string;
+    reliabilityScore: number;
+    status: string;
+    metadata?: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface TaskTemplateRecord {
+    id: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    defaultCapabilities: string[];
+    suggestedPaths: string[];
+    archetypeScope: string | null;
+    defaultRiskLevel: string | null;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
 export interface AgentSessionRequest {
     workspaceId: string;
     agentName: string;
@@ -122,3 +174,120 @@ export interface MemoryDraftRecord {
     updatedAt?: string;
     [key: string]: unknown;
 }
+export interface MemorySearchRecord {
+    id: string;
+    workspaceId: string;
+    docType: MemoryDraftType;
+    authority: string;
+    title: string;
+    memoryKey: string | null;
+    excerpt: string;
+    score: number;
+    createdAt: string;
+    metadata?: Record<string, unknown> | null;
+}
+export interface TaskCreateRequest {
+    title: string;
+    intention: string;
+    templateSlug?: string;
+    requestedCapabilities?: string[];
+    targetPaths?: string[];
+    featureKey?: string;
+    taskKey?: string;
+}
+export interface TaskStepRecord {
+    id: string;
+    order: number;
+    name: string;
+    capability: string;
+    status: string;
+    assignedAgentId?: string | null;
+    assignedAgentName?: string | null;
+    output?: Record<string, unknown> | null;
+    lastError?: string | null;
+    [key: string]: unknown;
+}
+export interface ClaimableTaskStepRecord {
+    workspaceId: string;
+    taskId: string;
+    taskTitle: string;
+    stepId: string;
+    stepName: string;
+    capability: string;
+    status: string;
+    assignedAgentId: string;
+    assignedAgentName: string;
+    execution?: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ClaimedTaskStepResponse {
+    task: TaskRecord;
+    claim: ClaimableTaskStepRecord;
+}
+export interface TaskRecord {
+    id: string;
+    workspaceId: string;
+    title: string;
+    intention: string;
+    status: string;
+    riskLevel: string;
+    riskScore: number;
+    policyStatus: string;
+    conflictStatus: string;
+    requiresApproval?: boolean;
+    approvedBy?: string | null;
+    handoffSummary?: Record<string, unknown> | null;
+    requestedCapabilities: string[];
+    targetPaths: string[];
+    warnings: string[];
+    recommendedApproach?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    handoffs?: Array<{
+        id: string;
+        title: string;
+        summary?: Record<string, unknown> | null;
+        nextSteps?: string[];
+        risks?: string[];
+        createdAt: string;
+    }>;
+    steps: TaskStepRecord[];
+    [key: string]: unknown;
+}
+export interface TaskHandoffRecord {
+    taskId: string;
+    workspaceId: string;
+    status: string;
+    title: string;
+    currentTitle?: string;
+    currentSummary?: Record<string, unknown> | null;
+    nextSteps?: string[];
+    risks?: string[];
+    memoryLanes?: string[];
+    [key: string]: unknown;
+}
+export interface TaskObservabilityRecord {
+    workspaceId: string;
+    taskId?: string;
+    title?: string;
+    status?: string;
+    riskLevel?: string;
+    policyStatus?: string;
+    conflictStatus?: string;
+    durationMs?: number;
+    delegationCount?: number;
+    handoffCount?: number;
+    attempts?: number;
+    totalTasks?: number;
+    completedTasks?: number;
+    failedTasks?: number;
+    blockedTasks?: number;
+    delegatedTasks?: number;
+    averageDurationMs?: number;
+    successRate?: number;
+    recentTasks?: Array<Record<string, unknown>>;
+    steps?: Array<Record<string, unknown>>;
+    timeline?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectorplane/ctrl-cli",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Official VectorPlane CLI.",
   "type": "module",
   "main": "./dist/index.js",