@thiagodiogo/pastelsdd 1.0.0-beta.1

package/dist/commands/workflow/shared.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared Types and Utilities for Artifact Workflow Commands
+ *
+ * This module contains types, constants, and validation helpers used across
+ * multiple artifact workflow commands.
+ */
+import type { InitiativeLink } from '../../core/change-metadata/index.js';
+export interface TaskItem {
+    id: string;
+    description: string;
+    done: boolean;
+}
+export interface ApplyInstructions {
+    changeName: string;
+    changeDir: string;
+    schemaName: string;
+    initiative?: InitiativeLink;
+    contextFiles: Record<string, string[]>;
+    progress: {
+        total: number;
+        complete: number;
+        remaining: number;
+    };
+    tasks: TaskItem[];
+    state: 'blocked' | 'all_done' | 'ready';
+    missingArtifacts?: string[];
+    instruction: string;
+}
+export declare const DEFAULT_SCHEMA = "spec-driven";
+/**
+ * Checks if color output is disabled via NO_COLOR env or --no-color flag.
+ */
+export declare function isColorDisabled(): boolean;
+/**
+ * Gets the color function based on status.
+ */
+export declare function getStatusColor(status: 'done' | 'ready' | 'blocked'): (text: string) => string;
+/**
+ * Gets the status indicator for an artifact.
+ */
+export declare function getStatusIndicator(status: 'done' | 'ready' | 'blocked'): string;
+/**
+ * Returns the list of available change directory names under pastelsdd/changes/.
+ * Excludes the archive directory and hidden directories.
+ */
+export declare function getAvailableChanges(projectRoot: string, changesDir?: string): Promise<string[]>;
+/**
+ * Validates that a change exists and returns available changes if not.
+ * Checks directory existence directly to support scaffolded changes (without proposal.md).
+ */
+export declare function validateChangeExists(changeName: string | undefined, projectRoot: string, changesDir?: string): Promise<string>;
+/**
+ * Validates that a schema exists and returns available schemas if not.
+ *
+ * @param schemaName - The schema name to validate
+ * @param projectRoot - Optional project root for project-local schema resolution
+ */
+export declare function validateSchemaExists(schemaName: string, projectRoot?: string): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/workflow/shared.js

@@ -0,0 +1,116 @@
+/**
+ * Shared Types and Utilities for Artifact Workflow Commands
+ *
+ * This module contains types, constants, and validation helpers used across
+ * multiple artifact workflow commands.
+ */
+import chalk from 'chalk';
+import path from 'path';
+import * as fs from 'fs';
+import { getSchemaDir, listSchemas } from '../../core/artifact-graph/index.js';
+import { validateChangeName } from '../../utils/change-utils.js';
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+export const DEFAULT_SCHEMA = 'spec-driven';
+// -----------------------------------------------------------------------------
+// Utility Functions
+// -----------------------------------------------------------------------------
+/**
+ * Checks if color output is disabled via NO_COLOR env or --no-color flag.
+ */
+export function isColorDisabled() {
+    return process.env.NO_COLOR === '1' || process.env.NO_COLOR === 'true';
+}
+/**
+ * Gets the color function based on status.
+ */
+export function getStatusColor(status) {
+    if (isColorDisabled()) {
+        return (text) => text;
+    }
+    switch (status) {
+        case 'done':
+            return chalk.green;
+        case 'ready':
+            return chalk.yellow;
+        case 'blocked':
+            return chalk.red;
+    }
+}
+/**
+ * Gets the status indicator for an artifact.
+ */
+export function getStatusIndicator(status) {
+    const color = getStatusColor(status);
+    switch (status) {
+        case 'done':
+            return color('[x]');
+        case 'ready':
+            return color('[ ]');
+        case 'blocked':
+            return color('[-]');
+    }
+}
+/**
+ * Returns the list of available change directory names under pastelsdd/changes/.
+ * Excludes the archive directory and hidden directories.
+ */
+export async function getAvailableChanges(projectRoot, changesDir = path.join(projectRoot, 'pastelsdd', 'changes')) {
+    const changesPath = changesDir;
+    try {
+        const entries = await fs.promises.readdir(changesPath, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isDirectory() && e.name !== 'archive' && !e.name.startsWith('.'))
+            .map((e) => e.name);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+/**
+ * Validates that a change exists and returns available changes if not.
+ * Checks directory existence directly to support scaffolded changes (without proposal.md).
+ */
+export async function validateChangeExists(changeName, projectRoot, changesDir = path.join(projectRoot, 'pastelsdd', 'changes')) {
+    if (!changeName) {
+        const available = await getAvailableChanges(projectRoot, changesDir);
+        if (available.length === 0) {
+            throw new Error('No changes found. Create one with: pastelsdd new change <name>');
+        }
+        throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
+    }
+    // Validate change name format to prevent path traversal
+    const nameValidation = validateChangeName(changeName);
+    if (!nameValidation.valid) {
+        throw new Error(`Invalid change name '${changeName}': ${nameValidation.error}`);
+    }
+    // Check directory existence directly
+    const changePath = path.join(changesDir, changeName);
+    const exists = fs.existsSync(changePath) && fs.statSync(changePath).isDirectory();
+    if (!exists) {
+        const available = await getAvailableChanges(projectRoot, changesDir);
+        if (available.length === 0) {
+            throw new Error(`Change '${changeName}' not found. No changes exist. Create one with: pastelsdd new change <name>`);
+        }
+        throw new Error(`Change '${changeName}' not found. Available changes:\n  ${available.join('\n  ')}`);
+    }
+    return changeName;
+}
+/**
+ * Validates that a schema exists and returns available schemas if not.
+ *
+ * @param schemaName - The schema name to validate
+ * @param projectRoot - Optional project root for project-local schema resolution
+ */
+export function validateSchemaExists(schemaName, projectRoot) {
+    const schemaDir = getSchemaDir(schemaName, projectRoot);
+    if (!schemaDir) {
+        const availableSchemas = listSchemas(projectRoot);
+        throw new Error(`Schema '${schemaName}' not found. Available schemas:\n  ${availableSchemas.join('\n  ')}`);
+    }
+    return schemaName;
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/workflow/status.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Status Command
+ *
+ * Displays artifact completion status for a change.
+ */
+import { type ChangeStatus } from '../../core/artifact-graph/index.js';
+export interface StatusOptions {
+    change?: string;
+    schema?: string;
+    json?: boolean;
+}
+export declare function statusCommand(options: StatusOptions): Promise<void>;
+export declare function printStatusText(status: ChangeStatus): void;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/workflow/status.js

@@ -0,0 +1,90 @@
+/**
+ * Status Command
+ *
+ * Displays artifact completion status for a change.
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import { resolveCurrentPlanningHomeSync, getChangeDir } from '../../core/planning-home.js';
+import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
+import { validateChangeExists, validateSchemaExists, getAvailableChanges, getStatusIndicator, getStatusColor, } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function statusCommand(options) {
+    const spinner = options.json ? undefined : ora('Loading change status...').start();
+    try {
+        const planningHome = resolveCurrentPlanningHomeSync();
+        const projectRoot = planningHome.root;
+        // Handle no-changes case gracefully — status is informational,
+        // so "no changes" is a valid state, not an error.
+        if (!options.change) {
+            const available = await getAvailableChanges(projectRoot, planningHome.changesDir);
+            if (available.length === 0) {
+                spinner?.stop();
+                if (options.json) {
+                    console.log(JSON.stringify({ changes: [], message: 'No active changes.' }, null, 2));
+                    return;
+                }
+                console.log('No active changes. Create one with: pastelsdd new change <name>');
+                return;
+            }
+            // Changes exist but --change not provided
+            spinner?.stop();
+            throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
+        }
+        const changeName = await validateChangeExists(options.change, projectRoot, planningHome.changesDir);
+        // Validate schema if explicitly provided
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        // loadChangeContext will auto-detect schema from metadata if not provided
+        const context = loadChangeContext(projectRoot, changeName, options.schema, {
+            changeDir: getChangeDir(planningHome, changeName),
+            planningHome,
+        });
+        const status = formatChangeStatus(context);
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        printStatusText(status);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printStatusText(status) {
+    const doneCount = status.artifacts.filter((a) => a.status === 'done').length;
+    const total = status.artifacts.length;
+    console.log(`Change: ${status.changeName}`);
+    console.log(`Schema: ${status.schemaName}`);
+    if (status.initiative) {
+        console.log(`Initiative: ${status.initiative.store}/${status.initiative.id}`);
+    }
+    if (status.planningHome) {
+        const label = status.planningHome.kind === 'workspace'
+            ? `workspace${status.planningHome.workspaceName ? ` (${status.planningHome.workspaceName})` : ''}`
+            : 'repo';
+        console.log(`Planning home: ${label}`);
+        console.log(`Change root: ${status.changeRoot}`);
+    }
+    console.log(`Progress: ${doneCount}/${total} artifacts complete`);
+    console.log();
+    for (const artifact of status.artifacts) {
+        const indicator = getStatusIndicator(artifact.status);
+        const color = getStatusColor(artifact.status);
+        let line = `${indicator} ${artifact.id}`;
+        if (artifact.status === 'blocked' && artifact.missingDeps && artifact.missingDeps.length > 0) {
+            line += color(` (blocked by: ${artifact.missingDeps.join(', ')})`);
+        }
+        console.log(line);
+    }
+    if (status.isComplete) {
+        console.log();
+        console.log(chalk.green('All artifacts complete!'));
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/workflow/templates.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+export interface TemplatesOptions {
+    schema?: string;
+    json?: boolean;
+}
+export interface TemplateInfo {
+    artifactId: string;
+    templatePath: string;
+    source: 'project' | 'user' | 'package';
+}
+export declare function templatesCommand(options: TemplatesOptions): Promise<void>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/commands/workflow/templates.js

@@ -0,0 +1,69 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+import ora from 'ora';
+import path from 'path';
+import { resolveSchema, getSchemaDir, ArtifactGraph, } from '../../core/artifact-graph/index.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { validateSchemaExists, DEFAULT_SCHEMA } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function templatesCommand(options) {
+    const spinner = options.json ? undefined : ora('Loading templates...').start();
+    try {
+        const projectRoot = process.cwd();
+        const schemaName = validateSchemaExists(options.schema ?? DEFAULT_SCHEMA, projectRoot);
+        const schema = resolveSchema(schemaName, projectRoot);
+        const graph = ArtifactGraph.fromSchema(schema);
+        const schemaDir = getSchemaDir(schemaName, projectRoot);
+        // Determine the source (project, user, or package)
+        const { getUserSchemasDir, getProjectSchemasDir, } = await import('../../core/artifact-graph/resolver.js');
+        const projectSchemasDir = getProjectSchemasDir(projectRoot);
+        const userSchemasDir = getUserSchemasDir();
+        // Determine source by checking if schemaDir is inside each base directory
+        // Using path.relative is more robust than startsWith for path comparisons
+        const isInsideDir = (child, parent) => {
+            const relative = path.relative(parent, child);
+            return !relative.startsWith('..') && !path.isAbsolute(relative);
+        };
+        let source;
+        if (isInsideDir(schemaDir, projectSchemasDir)) {
+            source = 'project';
+        }
+        else if (isInsideDir(schemaDir, userSchemasDir)) {
+            source = 'user';
+        }
+        else {
+            source = 'package';
+        }
+        const templates = graph.getAllArtifacts().map((artifact) => ({
+            artifactId: artifact.id,
+            templatePath: FileSystemUtils.canonicalizeExistingPath(path.join(schemaDir, 'templates', artifact.template)),
+            source,
+        }));
+        spinner?.stop();
+        if (options.json) {
+            const output = {};
+            for (const t of templates) {
+                output[t.artifactId] = { path: t.templatePath, source: t.source };
+            }
+            console.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        console.log(`Schema: ${schemaName}`);
+        console.log(`Source: ${source}`);
+        console.log();
+        for (const t of templates) {
+            console.log(`${t.artifactId}:`);
+            console.log(`  ${t.templatePath}`);
+        }
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+//# sourceMappingURL=templates.js.map

package/dist/commands/workspace/context-status.d.ts

@@ -0,0 +1,4 @@
+import { type WorkspaceContextState } from '../../core/workspace/index.js';
+import { WorkspaceStatus } from './types.js';
+export declare function collectWorkspaceContextStatuses(context: WorkspaceContextState | null): Promise<WorkspaceStatus[]>;
+//# sourceMappingURL=context-status.d.ts.map

package/dist/commands/workspace/context-status.js

@@ -0,0 +1,59 @@
+import { mountInitiativesCollection, readInitiative, } from '../../core/collections/initiatives/index.js';
+import { formatContextStoreBinding, formatContextStoreBindingSelector, resolveContextStoreBinding, } from '../../core/context-store/index.js';
+import { getWorkspaceContextInitiativeId, } from '../../core/workspace/index.js';
+import { asErrorMessage, makeStatus } from './types.js';
+function contextStoreBindingWarningToStatus(warning) {
+    return makeStatus('warning', warning.code, warning.message, {
+        target: warning.target ? `workspace.context.store.${warning.target}` : 'workspace.context.store',
+        ...(warning.fix ? { fix: warning.fix } : {}),
+    });
+}
+export async function collectWorkspaceContextStatuses(context) {
+    if (!context) {
+        return [];
+    }
+    const initiativeId = getWorkspaceContextInitiativeId(context);
+    const contextStoreLabel = formatContextStoreBinding(context.store);
+    const selector = formatContextStoreBindingSelector(context.store);
+    let resolvedStore;
+    try {
+        resolvedStore = await resolveContextStoreBinding(context.store);
+    }
+    catch (error) {
+        return [
+            makeStatus('error', 'workspace_context_store_unavailable', `Workspace context store '${contextStoreLabel}' could not be read: ${asErrorMessage(error)}`, {
+                target: 'workspace.context.store',
+                fix: context.store.selector.kind === 'registry'
+                    ? 'pastelsdd context-store doctor'
+                    : `Check the path in workspace.yaml or run pastelsdd initiative show ${initiativeId} ${selector}`,
+            }),
+        ];
+    }
+    const statuses = resolvedStore.warnings.map(contextStoreBindingWarningToStatus);
+    try {
+        const initiative = await readInitiative({
+            collection: mountInitiativesCollection(resolvedStore.root),
+            id: initiativeId,
+        });
+        if (!initiative) {
+            return [
+                ...statuses,
+                makeStatus('error', 'workspace_initiative_missing', `Workspace initiative '${contextStoreLabel}/${initiativeId}' was not found.`, {
+                    target: 'workspace.context.initiative',
+                    fix: `pastelsdd initiative show ${initiativeId} ${selector}`,
+                }),
+            ];
+        }
+        return statuses;
+    }
+    catch (error) {
+        return [
+            ...statuses,
+            makeStatus('error', 'workspace_initiative_unavailable', `Workspace initiative '${contextStoreLabel}/${initiativeId}' could not be read: ${asErrorMessage(error)}`, {
+                target: 'workspace.context.initiative',
+                fix: `pastelsdd initiative show ${initiativeId} ${selector}`,
+            }),
+        ];
+    }
+}
+//# sourceMappingURL=context-status.js.map

package/dist/commands/workspace/open-view.d.ts

@@ -0,0 +1,62 @@
+import { InitiativeViewReference } from '../../core/collections/initiatives/index.js';
+import { type ContextStoreBinding } from '../../core/context-store/index.js';
+import { WorkspaceContextState, WorkspacePreferredOpener } from '../../core/workspace/index.js';
+import { type WorkspaceOpenCommandBuildResult } from './open.js';
+import { SelectedWorkspace, WorkspaceOpenOptions, WorkspaceStatus } from './types.js';
+export interface PreparedWorkspaceOpen extends WorkspaceOpenCommandBuildResult {
+    selected: SelectedWorkspace;
+    opener: WorkspacePreferredOpener;
+    initiative: InitiativeViewReference | null;
+    workspaceContext: WorkspaceContextState | null;
+    warnings: WorkspaceStatus[];
+}
+export interface WorkspaceOpenJsonPayload {
+    schema_version: 1;
+    workspace: {
+        name: string;
+        root: string;
+    };
+    context: {
+        context_store: {
+            id: string;
+            root: string;
+            selector?: ContextStoreBinding['selector'];
+        };
+        initiative: {
+            id: string;
+            title: string;
+            root: string;
+            metadata_path: string;
+            store_path: string;
+        };
+    } | null;
+    generated_files: {
+        agents: string;
+        code_workspace: string;
+    };
+    opened_roots: PreparedWorkspaceOpen['openedRoots'];
+    skipped_roots: Array<{
+        kind: 'link';
+        name: string;
+        path: string | null;
+        reason: PreparedWorkspaceOpen['skipped'][number]['reason'];
+    }>;
+    advisory_edit_boundaries: {
+        allowed_edit_roots: string[];
+        coordination_roots: string[];
+        enforcement: 'advisory';
+    };
+    opener: PreparedWorkspaceOpen['opener'] & {
+        label: string;
+    };
+    launch: {
+        attempted: true;
+        status: 'succeeded';
+    };
+    warnings: WorkspaceStatus[];
+    status: WorkspaceStatus[];
+}
+export declare function assertWorkspaceOpenSupportedOptions(options: WorkspaceOpenOptions): void;
+export declare function prepareWorkspaceOpen(positionalName: string | undefined, options: WorkspaceOpenOptions): Promise<PreparedWorkspaceOpen>;
+export declare function buildWorkspaceOpenJsonPayload(prepared: PreparedWorkspaceOpen): WorkspaceOpenJsonPayload;
+//# sourceMappingURL=open-view.d.ts.map