@thiagodiogo/pastelsdd 1.0.0-beta.1

package/dist/commands/workspace/registration.js

@@ -0,0 +1,84 @@
+import { getWorkspaceSkillToolIds } from '../../core/workspace/index.js';
+function collectOption(value, previous) {
+    return [...previous, value];
+}
+function addWorkspaceSelectionOptions(command) {
+    return command
+        .option('--workspace <name>', 'Workspace name from known local workspace views')
+        .option('--json', 'Output as JSON')
+        .option('--no-interactive', 'Disable prompts');
+}
+export function registerWorkspaceCommandWith(program, workspaceCommand) {
+    const workspace = program
+        .command('workspace')
+        .description('Set up and inspect coordination workspaces');
+    workspace
+        .command('setup')
+        .description('Set up a workspace and link existing repos or folders')
+        .option('--name <name>', 'Workspace name')
+        .option('--link <link>', 'Repo or folder link. Use <path> or <name>=<path>.', collectOption, [])
+        .option('--opener <id>', 'Preferred opener: codex, claude, github-copilot, or editor')
+        .option('--tools <tools>', `Install Pastelsdd skills for agents. Use "all", "none", or a comma-separated list of: ${getWorkspaceSkillToolIds().join(', ')}`)
+        .option('--json', 'Output as JSON')
+        .option('--no-interactive', 'Disable prompts')
+        .action(async (options) => {
+        await workspaceCommand.setup(options);
+    });
+    workspace
+        .command('list')
+        .description('List known Pastelsdd workspaces')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        await workspaceCommand.list(options);
+    });
+    workspace
+        .command('ls')
+        .description('List known Pastelsdd workspaces')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        await workspaceCommand.list(options);
+    });
+    addWorkspaceSelectionOptions(workspace
+        .command('link [nameOrPath] [path]')
+        .description('Link an existing repo or folder to a workspace')).action(async (nameOrPath, linkPath, options) => {
+        await workspaceCommand.link(nameOrPath, linkPath, options);
+    });
+    addWorkspaceSelectionOptions(workspace
+        .command('relink <name> <path>')
+        .description('Update the local path for an existing workspace link')).action(async (linkName, linkPath, options) => {
+        await workspaceCommand.relink(linkName, linkPath, options);
+    });
+    addWorkspaceSelectionOptions(workspace
+        .command('doctor')
+        .description('Check what a workspace can resolve on this machine')).action(async (options) => {
+        await workspaceCommand.doctor(options);
+    });
+    workspace
+        .command('update [name]')
+        .description('Refresh workspace-local Pastelsdd guidance and agent skills')
+        .option('--workspace <name>', 'Workspace name from known local workspace views')
+        .option('--tools <tools>', `Select agents for workspace skills. Use "all", "none", or a comma-separated list of: ${getWorkspaceSkillToolIds().join(', ')}. Global profile selects workflows; --tools selects agents.`)
+        .option('--json', 'Output as JSON')
+        .option('--no-interactive', 'Disable prompts')
+        .action(async (name, options) => {
+        await workspaceCommand.update(name, options);
+    });
+    workspace
+        .command('open [name]')
+        .description('Open a workspace in an agent or VS Code editor')
+        .option('--workspace <name>', 'Workspace name from known local workspace views')
+        .option('--initiative <id>', 'Open an initiative as a local workspace view')
+        .option('--store <id>', 'Context store id for --initiative')
+        .option('--store-path <path>', 'Existing local context store root for --initiative')
+        .option('--agent <tool>', 'Use an agent for this session: codex, claude, or github-copilot')
+        .option('--editor', 'Open the workspace in VS Code editor mode')
+        .option('--prepare-only', 'Unsupported: preview surfaces belong to a future context/query command')
+        .option('--json', 'Output generated workspace view context as JSON after launch')
+        .option('--change <id>', 'Unsupported: change-scoped open belongs to future workspace change planning')
+        .option('--no-interactive', 'Disable prompts')
+        .action(async (name, options) => {
+        await workspaceCommand.open(name, options);
+    });
+    // Intentionally no public `workspace create` command in this slice.
+}
+//# sourceMappingURL=registration.js.map

package/dist/commands/workspace/selection.d.ts

@@ -0,0 +1,6 @@
+import { SelectedWorkspace, WorkspaceSelectionOptions } from './types.js';
+export declare function selectWorkspaceRootForCommand(workspaceRoot: string): Promise<SelectedWorkspace>;
+export declare function selectWorkspaceForCommand(options: WorkspaceSelectionOptions, commandName: string, selectionOptions?: {
+    preferPositionalName?: boolean;
+}): Promise<SelectedWorkspace>;
+//# sourceMappingURL=selection.d.ts.map

package/dist/commands/workspace/selection.js

@@ -0,0 +1,122 @@
+import { findWorkspaceRoot, listKnownWorkspaceEntries, readWorkspaceViewState, } from '../../core/workspace/index.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
+import { validateWorkspaceNameForSetup } from './operations.js';
+import { WorkspaceCliError, makeStatus, } from './types.js';
+function normalizeRegistryRootForComparison(workspaceRoot) {
+    try {
+        return FileSystemUtils.canonicalizeExistingPath(workspaceRoot);
+    }
+    catch {
+        return workspaceRoot;
+    }
+}
+function workspaceNotInKnownViewsWarning() {
+    return makeStatus('warning', 'workspace_not_in_known_views', 'This workspace is not in the managed local workspace views list.', {
+        target: 'workspace.root',
+        fix: 'Use pastelsdd workspace list to inspect managed workspace views.',
+    });
+}
+function sameWorkspaceRoot(knownRoot, currentWorkspaceRoot) {
+    return (knownRoot !== undefined &&
+        normalizeRegistryRootForComparison(knownRoot) ===
+            normalizeRegistryRootForComparison(currentWorkspaceRoot));
+}
+function findKnownWorkspaceByName(entries, workspaceName) {
+    return entries.find((entry) => entry.name === workspaceName);
+}
+async function selectedWorkspaceFromRoot(currentWorkspaceRoot, entries) {
+    const viewState = await readWorkspaceViewState(currentWorkspaceRoot);
+    const knownRoot = findKnownWorkspaceByName(entries, viewState.name)?.workspaceRoot;
+    const isKnown = sameWorkspaceRoot(knownRoot, currentWorkspaceRoot);
+    return {
+        name: viewState.name,
+        root: currentWorkspaceRoot,
+        status: isKnown ? [] : [workspaceNotInKnownViewsWarning()],
+        unregisteredCurrentWorkspace: !isKnown,
+    };
+}
+export async function selectWorkspaceRootForCommand(workspaceRoot) {
+    const entries = await listKnownWorkspaceEntries();
+    const currentWorkspaceRoot = await findWorkspaceRoot(workspaceRoot);
+    if (!currentWorkspaceRoot) {
+        throw new WorkspaceCliError(`No Pastelsdd workspace found at '${workspaceRoot}'.`, 'workspace_not_found', {
+            target: 'workspace.root',
+            fix: 'Pass a path inside an Pastelsdd workspace.',
+        });
+    }
+    return selectedWorkspaceFromRoot(currentWorkspaceRoot, entries);
+}
+export async function selectWorkspaceForCommand(options, commandName, selectionOptions = {}) {
+    const entries = await listKnownWorkspaceEntries();
+    if (options.workspace) {
+        const workspaceName = validateWorkspaceNameForSetup(options.workspace);
+        const entry = findKnownWorkspaceByName(entries, workspaceName);
+        if (!entry) {
+            throw new WorkspaceCliError(`Unknown Pastelsdd workspace '${workspaceName}'.`, 'workspace_not_found', {
+                target: 'workspace.name',
+                fix: 'Run pastelsdd workspace list to see known workspaces.',
+            });
+        }
+        return {
+            name: workspaceName,
+            root: entry.workspaceRoot,
+            status: [],
+            unregisteredCurrentWorkspace: false,
+        };
+    }
+    const currentWorkspaceRoot = await findWorkspaceRoot(process.cwd());
+    if (currentWorkspaceRoot) {
+        return selectedWorkspaceFromRoot(currentWorkspaceRoot, entries);
+    }
+    if (entries.length === 0) {
+        throw new WorkspaceCliError("No known Pastelsdd workspaces. Run 'pastelsdd workspace setup' first.\nAfter at least one workspace is known locally, you can also pass --workspace <name>.", 'no_known_workspaces', {
+            target: 'workspace.name',
+            fix: 'pastelsdd workspace setup',
+        });
+    }
+    if (entries.length === 1) {
+        const [entry] = entries;
+        return {
+            name: entry.name,
+            root: entry.workspaceRoot,
+            status: [],
+            unregisteredCurrentWorkspace: false,
+        };
+    }
+    if (options.json || resolveNoInteractive(options) || !isInteractive(options)) {
+        const knownNames = entries.map((entry) => entry.name).join(', ');
+        const usesPositionalName = selectionOptions.preferPositionalName;
+        const fix = usesPositionalName
+            ? `pastelsdd workspace ${commandName} <name>`
+            : `pastelsdd workspace ${commandName} --workspace <name>`;
+        throw new WorkspaceCliError(usesPositionalName
+            ? `Multiple Pastelsdd workspaces are known. Known workspaces: ${knownNames}. Pass a workspace name.`
+            : `Multiple Pastelsdd workspaces are known. Known workspaces: ${knownNames}. Pass --workspace <name>.`, 'workspace_selection_ambiguous', {
+            target: 'workspace.name',
+            fix,
+        });
+    }
+    const { select } = await import('@inquirer/prompts');
+    const selectedName = await select({
+        message: 'Select workspace:',
+        choices: entries.map((entry) => ({
+            name: `${entry.name} (${entry.workspaceRoot})`,
+            value: entry.name,
+        })),
+    });
+    const selectedEntry = findKnownWorkspaceByName(entries, selectedName);
+    if (!selectedEntry) {
+        throw new WorkspaceCliError(`Unknown Pastelsdd workspace '${selectedName}'.`, 'workspace_not_found', {
+            target: 'workspace.name',
+            fix: 'Run pastelsdd workspace list to see known workspaces.',
+        });
+    }
+    return {
+        name: selectedName,
+        root: selectedEntry.workspaceRoot,
+        status: [],
+        unregisteredCurrentWorkspace: false,
+    };
+}
+//# sourceMappingURL=selection.js.map

package/dist/commands/workspace/types.d.ts

@@ -0,0 +1,103 @@
+import type { ContextStoreSelector } from '../../core/context-store/index.js';
+export type StatusSeverity = 'error' | 'warning';
+export interface WorkspaceStatus {
+    severity: StatusSeverity;
+    code: string;
+    message: string;
+    target?: string;
+    fix?: string;
+    details?: Record<string, unknown>;
+}
+export interface WorkspaceLinkOutput {
+    name: string;
+    path: string | null;
+    repo_specs_path?: string | null;
+    status: WorkspaceStatus[];
+}
+export interface WorkspaceContextOutput {
+    store: string;
+    initiative: string;
+    store_selector: ContextStoreSelector;
+}
+export interface WorkspaceOutput {
+    name: string;
+    root: string;
+    planning_path: string;
+    state_path?: string;
+    context?: WorkspaceContextOutput | null;
+    links: WorkspaceLinkOutput[];
+    status: WorkspaceStatus[];
+}
+export interface WorkspaceListOutput {
+    name: string;
+    root: string;
+    context?: WorkspaceContextOutput | null;
+    links: WorkspaceLinkOutput[];
+    status: WorkspaceStatus[];
+}
+export interface WorkspaceSetupOptions {
+    name?: string;
+    link?: string[];
+    opener?: string;
+    tools?: string;
+    json?: boolean;
+    noInteractive?: boolean;
+    interactive?: boolean;
+}
+export interface WorkspaceSelectionOptions {
+    workspace?: string;
+    json?: boolean;
+    noInteractive?: boolean;
+    interactive?: boolean;
+}
+export type WorkspaceLinkOptions = WorkspaceSelectionOptions;
+export interface WorkspaceUpdateOptions extends WorkspaceSelectionOptions {
+    tools?: string;
+    force?: boolean;
+}
+export interface WorkspaceOpenOptions extends WorkspaceSelectionOptions {
+    agent?: string;
+    editor?: boolean;
+    prepareOnly?: boolean;
+    change?: string;
+    initiative?: string;
+    store?: string;
+    storePath?: string;
+}
+export interface WorkspaceListOptions {
+    json?: boolean;
+}
+export interface SelectedWorkspace {
+    name: string;
+    root: string;
+    status: WorkspaceStatus[];
+    unregisteredCurrentWorkspace: boolean;
+}
+export interface WorkspaceLinkMutationPayload {
+    workspace: WorkspaceOutput;
+    link: {
+        name: string;
+        path: string;
+        status: WorkspaceStatus[];
+    };
+    status: WorkspaceStatus[];
+}
+export declare class WorkspaceCliError extends Error {
+    readonly status: WorkspaceStatus;
+    constructor(message: string, code: string, options?: {
+        target?: string;
+        fix?: string;
+        details?: Record<string, unknown>;
+    });
+}
+export declare function makeStatus(severity: StatusSeverity, code: string, message: string, options?: {
+    target?: string;
+    fix?: string;
+    details?: Record<string, unknown>;
+}): WorkspaceStatus;
+export declare function asErrorMessage(error: unknown): string;
+export declare function asStatus(error: unknown): WorkspaceStatus;
+export declare function appendStatus<T extends {
+    status: WorkspaceStatus[];
+}>(payload: T, status: WorkspaceStatus): T;
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/workspace/types.js

@@ -0,0 +1,36 @@
+export class WorkspaceCliError extends Error {
+    status;
+    constructor(message, code, options = {}) {
+        super(message);
+        this.status = {
+            severity: 'error',
+            code,
+            message,
+            ...options,
+        };
+    }
+}
+export function makeStatus(severity, code, message, options = {}) {
+    return {
+        severity,
+        code,
+        message,
+        ...options,
+    };
+}
+export function asErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function asStatus(error) {
+    if (error instanceof WorkspaceCliError) {
+        return error.status;
+    }
+    return makeStatus('error', 'workspace_error', asErrorMessage(error));
+}
+export function appendStatus(payload, status) {
+    return {
+        ...payload,
+        status: [...payload.status, status],
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/commands/workspace.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+import { WorkspaceUpdateOptions } from './workspace/types.js';
+export declare function runWorkspaceUpdate(positionalName: string | undefined, options?: WorkspaceUpdateOptions): Promise<void>;
+export declare function runWorkspaceUpdateForRoot(workspaceRoot: string, options?: WorkspaceUpdateOptions): Promise<void>;
+export declare function registerWorkspaceCommand(program: Command): void;
+//# sourceMappingURL=workspace.d.ts.map