@vectorplane/ctrl-cli 0.1.10 → 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/core/workspace-binding.d.ts

@@ -3,12 +3,17 @@ import type { GitContext } from "../types/workspace.js";
 export declare function resolveWorkspaceRoot(cwd: string, git: GitContext): string;
 export declare function deriveClientInstanceId(machineId: string, workspaceRoot: string, git: GitContext): string;
 export declare function getBoundWorkspace(rootPath: string): Promise<string | null>;
+export declare function getWorkspaceBinding(rootPath: string): Promise<import("../types/config.js").WorkspaceBinding>;
 export declare function getBindingStore(): Promise<WorkspaceBindingStore>;
 export declare function bindWorkspaceToRoot(params: {
     rootPath: string;
     workspace: string;
     repoUrl: string | null;
     source: "manual" | "api-resolve" | "session";
+    configuredAgent?: "claude" | "cursor" | "windsurf" | "copilot" | "codex" | "generic" | null;
+    agentConfidence?: "high" | "medium" | "low" | null;
+    templatePath?: string | null;
+    agentConfiguredAt?: string | null;
 }): Promise<void>;
 export declare function clearBoundWorkspace(rootPath: string): Promise<void>;
 export declare function resolveWorkspacePreference(profile: CliProfileConfig, boundWorkspace: string | null): string | null;

package/dist/core/workspace-binding.js

@@ -17,6 +17,10 @@ export async function getBoundWorkspace(rootPath) {
     const store = await loadWorkspaceBindings();
     return store.bindings[rootPath]?.workspace ?? null;
 }
+export async function getWorkspaceBinding(rootPath) {
+    const store = await loadWorkspaceBindings();
+    return store.bindings[rootPath] ?? null;
+}
 export async function getBindingStore() {
     return loadWorkspaceBindings();
 }
@@ -27,6 +31,10 @@ export async function bindWorkspaceToRoot(params) {
         repoUrl: params.repoUrl,
         resolvedAt: new Date().toISOString(),
         source: params.source,
+        configuredAgent: params.configuredAgent ?? null,
+        agentConfidence: params.agentConfidence ?? null,
+        templatePath: params.templatePath ?? null,
+        agentConfiguredAt: params.agentConfiguredAt ?? null,
     });
 }
 export async function clearBoundWorkspace(rootPath) {

package/dist/core/workspace-resolution.d.ts

@@ -0,0 +1,12 @@
+import type { VectorPlaneApiClient } from "./api.js";
+import type { AuthSession } from "../types/auth.js";
+import type { CliProfileConfig } from "../types/config.js";
+import type { GitContext } from "../types/workspace.js";
+export declare function resolveAuthorizedWorkspace(params: {
+    apiClient: VectorPlaneApiClient;
+    accessToken: string;
+    git: GitContext;
+    explicitWorkspace?: string;
+    profile: CliProfileConfig;
+    session: AuthSession;
+}): Promise<string>;

package/dist/core/workspace-resolution.js

@@ -0,0 +1,24 @@
+import { ValidationError } from "./errors.js";
+export async function resolveAuthorizedWorkspace(params) {
+    if (params.git.remoteOrigin) {
+        const resolved = await params.apiClient.resolveWorkspaceByRepo(params.accessToken, {
+            repoUrl: params.git.remoteOrigin,
+            orgId: params.profile.orgId ?? undefined,
+        });
+        const resolvedWorkspace = String(resolved.workspaceId ?? resolved.id ?? resolved.slug ?? "");
+        const resolvedSlug = typeof resolved.slug === "string" ? resolved.slug : null;
+        if (params.explicitWorkspace && params.explicitWorkspace !== resolvedWorkspace && params.explicitWorkspace !== resolvedSlug) {
+            throw new ValidationError("O workspace solicitado não corresponde ao repositório remoto atual ou você não tem permissão para manipulá-lo.");
+        }
+        const workspace = resolvedWorkspace || resolvedSlug;
+        if (!workspace) {
+            throw new ValidationError("A API não retornou um identificador de workspace utilizável para o repositório atual.");
+        }
+        return workspace;
+    }
+    if (params.explicitWorkspace) {
+        return params.explicitWorkspace;
+    }
+    throw new ValidationError("Nenhum workspace resolvido para init. Configure um remote git correspondente ao workspace ou use --workspace com permissão válida.");
+}
+//# sourceMappingURL=workspace-resolution.js.map

package/dist/index.js

@@ -7,11 +7,14 @@ import { runContextCommand } from "./commands/context.js";
 import { runDoctorCommand } from "./commands/doctor.js";
 import { runDraftCommand } from "./commands/draft.js";
 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";
@@ -27,10 +30,13 @@ function printHelp() {
     process.stdout.write("Uso: vp <comando>\n");
     process.stdout.write("\n");
     process.stdout.write("Comandos principais:\n");
+    process.stdout.write("  init [--agent <tipo>] [--workspace <workspace>] [--force]\n");
     process.stdout.write("  login [--no-browser|--manual]\n");
     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");
@@ -52,12 +58,18 @@ export async function runCli(args) {
         switch (command) {
             case "login":
                 return runLoginCommand(cliVersion, rest);
+            case "init":
+                return runInitCommand(cliVersion, rest);
             case "sync":
                 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

@@ -6,6 +6,42 @@ export interface SyncRequest {
     hash: string;
     sent_at: string;
 }
+export interface WorkspaceAgentSetupFile {
+    filename: string;
+    description?: string;
+    content: string;
+}
+export interface WorkspaceAgentSetupCli {
+    package: string;
+    command: string;
+    install: string;
+    login: string;
+    status: string;
+    sync: string;
+    workspaceUse: string;
+    bootstrap: string;
+    context: string;
+    deliveryContext: string;
+    draftCreate: string;
+    draftList: string;
+    sessionCheckIn: string;
+    sessionHeartbeat: string;
+    sessionCheckOut: string;
+    eventSend: string;
+}
+export interface WorkspaceAgentSetup {
+    workspaceId: string;
+    orgId: string;
+    mcpUrl: string;
+    apiUrl: string;
+    repoUrl: string | null;
+    cli: WorkspaceAgentSetupCli;
+    agents: Record<string, WorkspaceAgentSetupFile>;
+    hooks: Record<string, WorkspaceAgentSetupFile>;
+    githubActions: WorkspaceAgentSetupFile;
+    installScript: WorkspaceAgentSetupFile;
+    [key: string]: unknown;
+}
 export interface SyncResponse {
     ok?: boolean;
     workspace?: string;
@@ -30,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;
@@ -86,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/dist/types/config.d.ts

@@ -60,6 +60,10 @@ export interface WorkspaceBinding {
     repoUrl: string | null;
     resolvedAt: string;
     source: "manual" | "api-resolve" | "session";
+    configuredAgent?: "claude" | "cursor" | "windsurf" | "copilot" | "codex" | "generic" | null;
+    agentConfidence?: "high" | "medium" | "low" | null;
+    templatePath?: string | null;
+    agentConfiguredAt?: string | null;
 }
 export interface WorkspaceBindingStore {
     bindings: Record<string, WorkspaceBinding>;

package/package.json

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