@chalksurf/cli 0.2.3 → 0.3.0

package/dist/lib/import-output.js

@@ -1,81 +0,0 @@
-export const buildCliImportSources = ({ resolvedSources, getExtra, }) => {
-    return resolvedSources.map((resolvedSource, sourceIndex) => ({
-        sourceIndex,
-        sourceInputIndex: resolvedSource.sourceInputIndex,
-        sourceId: resolvedSource.sourceInput.sourceId ?? null,
-        kind: resolvedSource.kind,
-        input: resolvedSource.input,
-        fileName: resolvedSource.fileName,
-        relativePath: resolvedSource.relativePath,
-        ...(getExtra ? getExtra(resolvedSource) : {}),
-    }));
-};
-export const summarizeCliImportJobs = ({ jobs, sourceCount, sourceInputCount, timedOut, }) => {
-    const summary = {
-        sourceCount,
-        sourceInputCount,
-        jobCount: jobs.length,
-        queued: 0,
-        pending: 0,
-        inProgress: 0,
-        completed: 0,
-        failed: 0,
-        timedOut,
-    };
-    for (const job of jobs) {
-        if (job.status === 'queued') {
-            summary.queued += 1;
-            continue;
-        }
-        if (job.status === 'pending') {
-            summary.pending += 1;
-            continue;
-        }
-        if (job.status === 'in_progress') {
-            summary.inProgress += 1;
-            continue;
-        }
-        if (job.status === 'completed') {
-            summary.completed += 1;
-            continue;
-        }
-        summary.failed += 1;
-    }
-    return summary;
-};
-export const formatCliImportSummary = (summary) => {
-    const parts = [];
-    if (summary.queued > 0) {
-        parts.push(`${summary.queued} queued`);
-    }
-    if (summary.pending > 0) {
-        parts.push(`${summary.pending} pending`);
-    }
-    if (summary.inProgress > 0) {
-        parts.push(`${summary.inProgress} in progress`);
-    }
-    if (summary.completed > 0) {
-        parts.push(`${summary.completed} completed`);
-    }
-    if (summary.failed > 0) {
-        parts.push(`${summary.failed} failed`);
-    }
-    if (summary.timedOut) {
-        parts.push('timed out');
-    }
-    return `Summary: ${parts.join(', ') || '0 jobs'}.`;
-};
-export const formatCliImportTranslationJobs = (translationJobs) => {
-    if (!translationJobs || translationJobs.length === 0) {
-        return [];
-    }
-    return [
-        `Queued ${translationJobs.length} translation job${translationJobs.length === 1 ? '' : 's'}:`,
-        ...translationJobs.map((job) => {
-            if (job.type === 'exercise_translation_generation') {
-                return `${job.jobId}  exercise ${job.exerciseId}  ${job.languages.join(', ')}`;
-            }
-            return `${job.jobId}  sheet ${job.exerciseSheetId}  ${job.language}`;
-        }),
-    ];
-};

package/dist/lib/manifest.js

@@ -1,353 +0,0 @@
-import { readFile, stat } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { z } from 'zod';
-import { CliCommandError } from './cli-error.js';
-import { translationLanguages } from './translation-languages.js';
-const isObject = (value) => {
-    return typeof value === 'object' && value !== null;
-};
-const normalizeOptionalString = (value) => {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const normalizedValue = value.trim();
-    return normalizedValue.length > 0 ? normalizedValue : undefined;
-};
-const translationLanguageListSchema = z
-    .array(z.enum(translationLanguages))
-    .min(1, { message: 'translateTo must include at least one language.' })
-    .refine((languages) => new Set(languages).size === languages.length, {
-    message: 'translateTo languages must be unique.',
-});
-const sheetImportComponentIdPattern = /^[a-zA-Z0-9_-]{1,80}$/;
-const parseTranslateTo = ({ value, label }) => {
-    if (value == null) {
-        return undefined;
-    }
-    const parsedLanguages = translationLanguageListSchema.safeParse(value);
-    if (!parsedLanguages.success) {
-        const issue = parsedLanguages.error.issues[0];
-        throw new CliCommandError(`${label} has invalid translateTo: ${issue?.message ?? 'Invalid languages.'}`, 2);
-    }
-    return parsedLanguages.data;
-};
-const parseManifestObject = (manifestText) => {
-    let parsedManifest;
-    try {
-        parsedManifest = JSON.parse(manifestText);
-    }
-    catch {
-        throw new CliCommandError('Manifest must be valid JSON.', 2);
-    }
-    if (!isObject(parsedManifest)) {
-        throw new CliCommandError('Manifest must be a JSON object.', 2);
-    }
-    return parsedManifest;
-};
-const parseSourceManifestObject = (manifestText) => {
-    const parsedManifest = parseManifestObject(manifestText);
-    if (!Array.isArray(parsedManifest.sources) || parsedManifest.sources.length === 0) {
-        throw new CliCommandError('Manifest must include a non-empty sources array.', 2);
-    }
-    return parsedManifest;
-};
-const isValidTargetFolderPath = (value) => {
-    const normalizedSegments = value
-        .replaceAll('\\', '/')
-        .split('/')
-        .filter((segment) => segment.length > 0);
-    return normalizedSegments.length > 0 && normalizedSegments.every((segment) => segment !== '.' && segment !== '..');
-};
-const parseTargetFolderPath = ({ value, label }) => {
-    if (value === null) {
-        return null;
-    }
-    const normalizedValue = normalizeOptionalString(value);
-    if (!normalizedValue) {
-        throw new CliCommandError(`${label} must include targetFolderPath as a string or null.`, 2);
-    }
-    if (!isValidTargetFolderPath(normalizedValue)) {
-        throw new CliCommandError(`${label} targetFolderPath must be a normalized folder path without "." or ".." segments.`, 2);
-    }
-    return normalizedValue;
-};
-const parseOptionalTargetFolderPath = ({ value, label }) => {
-    if (value == null) {
-        return null;
-    }
-    return parseTargetFolderPath({ value, label });
-};
-const parseSheetImportComponents = ({ value, sheetIndex, }) => {
-    if (value == null) {
-        return undefined;
-    }
-    if (!Array.isArray(value) || value.length === 0) {
-        throw new CliCommandError(`Manifest sheet at index ${sheetIndex} components must be a non-empty array.`, 2);
-    }
-    const seenComponentIds = new Set();
-    return value.map((componentValue, componentIndex) => {
-        const label = `Manifest sheet at index ${sheetIndex} component at index ${componentIndex}`;
-        if (!isObject(componentValue)) {
-            throw new CliCommandError(`${label} must be an object.`, 2);
-        }
-        const componentId = normalizeOptionalString(componentValue.componentId);
-        if (!componentId || !sheetImportComponentIdPattern.test(componentId)) {
-            throw new CliCommandError(`${label} must include a componentId using 1-80 letters, numbers, underscores, or hyphens.`, 2);
-        }
-        if (seenComponentIds.has(componentId)) {
-            throw new CliCommandError(`Manifest sheet at index ${sheetIndex} componentId "${componentId}" must be unique.`, 2);
-        }
-        seenComponentIds.add(componentId);
-        const description = normalizeOptionalString(componentValue.description);
-        if (!description) {
-            throw new CliCommandError(`${label} must include a non-empty description.`, 2);
-        }
-        return {
-            componentId,
-            description,
-            targetFolderPath: parseOptionalTargetFolderPath({
-                value: componentValue.targetFolderPath,
-                label,
-            }),
-            title: normalizeOptionalString(componentValue.title),
-            translateTo: parseTranslateTo({
-                value: componentValue.translateTo,
-                label,
-            }),
-        };
-    });
-};
-const parseManifestMetadata = ({ parsedManifest, topLevelFields, }) => {
-    const wait = typeof parsedManifest.wait === 'boolean' ? parsedManifest.wait : undefined;
-    return {
-        organizationId: normalizeOptionalString(parsedManifest.organizationId),
-        wait,
-        ...(topLevelFields.includes('exerciseId')
-            ? { exerciseId: normalizeOptionalString(parsedManifest.exerciseId) }
-            : {}),
-        ...(topLevelFields.includes('exerciseSheetId')
-            ? { exerciseSheetId: normalizeOptionalString(parsedManifest.exerciseSheetId) }
-            : {}),
-    };
-};
-const assertUniqueSourceIds = (sources) => {
-    const seenSourceIds = new Set();
-    for (const source of sources) {
-        if (!source.sourceId) {
-            continue;
-        }
-        if (seenSourceIds.has(source.sourceId)) {
-            throw new CliCommandError(`Manifest sourceId "${source.sourceId}" must be unique.`, 2);
-        }
-        seenSourceIds.add(source.sourceId);
-    }
-};
-const isInteractiveStdin = (stdin) => {
-    return stdin.isTTY === true;
-};
-const readTextFromStdin = async (stdin) => {
-    let text = '';
-    for await (const chunk of stdin) {
-        text += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
-    }
-    return text;
-};
-const parseBaseManifestSource = (value, index) => {
-    if (!isObject(value)) {
-        throw new CliCommandError(`Manifest source at index ${index} must be an object.`, 2);
-    }
-    const kind = normalizeOptionalString(value.kind);
-    const sourceId = normalizeOptionalString(value.sourceId);
-    if ('title' in value || 'translateTo' in value) {
-        throw new CliCommandError(`Manifest source at index ${index} cannot include title or translateTo for this command.`, 2);
-    }
-    if (kind === 'local') {
-        const path = normalizeOptionalString(value.path);
-        if (!path) {
-            throw new CliCommandError(`Manifest local source at index ${index} must include a path.`, 2);
-        }
-        return {
-            kind: 'local',
-            path,
-            relativePath: normalizeOptionalString(value.relativePath),
-            sourceId,
-        };
-    }
-    if (kind === 'directory') {
-        const path = normalizeOptionalString(value.path);
-        if (!path) {
-            throw new CliCommandError(`Manifest directory source at index ${index} must include a path.`, 2);
-        }
-        return {
-            kind: 'directory',
-            path,
-            relativeRoot: normalizeOptionalString(value.relativeRoot),
-            sourceId,
-        };
-    }
-    if (kind === 'url') {
-        const url = normalizeOptionalString(value.url);
-        if (!url) {
-            throw new CliCommandError(`Manifest URL source at index ${index} must include a url.`, 2);
-        }
-        return {
-            kind: 'url',
-            url,
-            relativePath: normalizeOptionalString(value.relativePath),
-            sourceId,
-        };
-    }
-    throw new CliCommandError(`Manifest source at index ${index} has unsupported kind "${String(value.kind)}".`, 2);
-};
-const parseExerciseImportManifest = (manifestText) => {
-    const parsedManifest = parseSourceManifestObject(manifestText);
-    const sources = parsedManifest.sources.map((source, index) => parseBaseManifestSource(source, index));
-    assertUniqueSourceIds(sources);
-    return {
-        ...parseManifestMetadata({
-            parsedManifest,
-            topLevelFields: ['exerciseSheetId'],
-        }),
-        translateTo: parseTranslateTo({
-            value: parsedManifest.translateTo,
-            label: 'Manifest',
-        }),
-        sources,
-    };
-};
-const parseExerciseSolutionImportManifest = (manifestText) => {
-    const parsedManifest = parseSourceManifestObject(manifestText);
-    const sources = parsedManifest.sources.map((source, index) => parseBaseManifestSource(source, index));
-    assertUniqueSourceIds(sources);
-    return {
-        ...parseManifestMetadata({
-            parsedManifest,
-            topLevelFields: ['exerciseId'],
-        }),
-        sources,
-    };
-};
-const parseExerciseSheetSolutionImportManifest = (manifestText) => {
-    const parsedManifest = parseSourceManifestObject(manifestText);
-    const sources = parsedManifest.sources.map((source, index) => parseBaseManifestSource(source, index));
-    assertUniqueSourceIds(sources);
-    return {
-        ...parseManifestMetadata({
-            parsedManifest,
-            topLevelFields: ['exerciseSheetId'],
-        }),
-        sources,
-    };
-};
-const parseSheetImportManifest = (manifestText) => {
-    const parsedManifest = parseManifestObject(manifestText);
-    if ('sources' in parsedManifest) {
-        throw new CliCommandError('Sheet import manifests must use top-level sheets[]. Top-level sources[] is no longer supported.', 2);
-    }
-    if (!Array.isArray(parsedManifest.sheets) || parsedManifest.sheets.length === 0) {
-        throw new CliCommandError('Manifest must include a non-empty sheets array.', 2);
-    }
-    const sources = [];
-    const sheetGroups = [];
-    parsedManifest.sheets.forEach((sheetValue, sheetIndex) => {
-        if (!isObject(sheetValue)) {
-            throw new CliCommandError(`Manifest sheet at index ${sheetIndex} must be an object.`, 2);
-        }
-        if (!Array.isArray(sheetValue.sources) || sheetValue.sources.length === 0) {
-            throw new CliCommandError(`Manifest sheet at index ${sheetIndex} must include a non-empty sources array.`, 2);
-        }
-        const sourceInputIndexes = sheetValue.sources.map((sourceValue) => {
-            const flattenedSourceIndex = sources.length;
-            const parsedSource = parseBaseManifestSource(sourceValue, flattenedSourceIndex);
-            sources.push(parsedSource);
-            return flattenedSourceIndex;
-        });
-        const components = parseSheetImportComponents({ value: sheetValue.components, sheetIndex });
-        if (components) {
-            if ('targetFolderPath' in sheetValue || 'title' in sheetValue || 'translateTo' in sheetValue) {
-                throw new CliCommandError(`Manifest sheet at index ${sheetIndex} must set targetFolderPath, title, and translateTo on components when components are provided.`, 2);
-            }
-            sheetGroups.push({
-                sourceInputIndexes,
-                components,
-            });
-            return;
-        }
-        sheetGroups.push({
-            sourceInputIndexes,
-            targetFolderPath: parseTargetFolderPath({
-                value: sheetValue.targetFolderPath,
-                label: `Manifest sheet at index ${sheetIndex}`,
-            }),
-            title: normalizeOptionalString(sheetValue.title),
-            translateTo: parseTranslateTo({
-                value: sheetValue.translateTo,
-                label: `Manifest sheet at index ${sheetIndex}`,
-            }),
-        });
-    });
-    assertUniqueSourceIds(sources);
-    return {
-        ...parseManifestMetadata({
-            parsedManifest,
-            topLevelFields: [],
-        }),
-        sources,
-        sheetGroups,
-    };
-};
-const loadManifest = async ({ cwd, manifestPath, parseManifest, stdin, }) => {
-    if (manifestPath === '-') {
-        if (isInteractiveStdin(stdin)) {
-            throw new CliCommandError('No manifest was piped on stdin. Pipe JSON into "--manifest -".', 2);
-        }
-        return parseManifest(await readTextFromStdin(stdin));
-    }
-    const resolvedManifestPath = resolve(cwd, manifestPath);
-    let fileStats;
-    try {
-        fileStats = await stat(resolvedManifestPath);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            throw new CliCommandError(`Manifest file "${manifestPath}" does not exist.`, 2);
-        }
-        throw error;
-    }
-    if (!fileStats.isFile()) {
-        throw new CliCommandError(`Manifest path "${manifestPath}" is not a file.`, 2);
-    }
-    return parseManifest(await readFile(resolvedManifestPath, 'utf8'));
-};
-export const loadExerciseImportManifest = async ({ cwd, manifestPath, stdin, }) => {
-    return await loadManifest({
-        cwd,
-        manifestPath,
-        parseManifest: parseExerciseImportManifest,
-        stdin,
-    });
-};
-export const loadExerciseSolutionImportManifest = async ({ cwd, manifestPath, stdin, }) => {
-    return await loadManifest({
-        cwd,
-        manifestPath,
-        parseManifest: parseExerciseSolutionImportManifest,
-        stdin,
-    });
-};
-export const loadExerciseSheetSolutionImportManifest = async ({ cwd, manifestPath, stdin, }) => {
-    return await loadManifest({
-        cwd,
-        manifestPath,
-        parseManifest: parseExerciseSheetSolutionImportManifest,
-        stdin,
-    });
-};
-export const loadSheetImportManifest = async ({ cwd, manifestPath, stdin, }) => {
-    return await loadManifest({
-        cwd,
-        manifestPath,
-        parseManifest: parseSheetImportManifest,
-        stdin,
-    });
-};

package/dist/lib/output.js

@@ -1,57 +0,0 @@
-const cliJsonSchemaVersion = 'v1';
-const ensureTrailingNewline = (value) => {
-    return value.endsWith('\n') ? value : `${value}\n`;
-};
-const writeLine = (writer, value) => {
-    writer.write(ensureTrailingNewline(value));
-};
-export const createOutput = ({ json, stdout, stderr, }) => {
-    let warnings = [];
-    const consumeWarnings = () => {
-        const nextWarnings = warnings;
-        warnings = [];
-        return nextWarnings;
-    };
-    return {
-        json,
-        print: (value, humanFormatter, options) => {
-            if (json) {
-                writeLine(stdout, JSON.stringify({
-                    schemaVersion: cliJsonSchemaVersion,
-                    command: options.command,
-                    ok: options.ok ?? true,
-                    result: value,
-                    ...(options.error ? { error: options.error } : {}),
-                    warnings: consumeWarnings(),
-                }, null, 2));
-                return;
-            }
-            const message = typeof humanFormatter === 'function' ? humanFormatter(value) : humanFormatter;
-            writeLine(stdout, message);
-        },
-        printError: ({ command, error, result }) => {
-            if (json) {
-                writeLine(stdout, JSON.stringify({
-                    schemaVersion: cliJsonSchemaVersion,
-                    command,
-                    ok: false,
-                    ...(result === undefined ? {} : { result }),
-                    error,
-                    warnings: consumeWarnings(),
-                }, null, 2));
-                return;
-            }
-            writeLine(stderr, error.message);
-        },
-        info: (message) => {
-            if (json) {
-                warnings.push(message);
-                return;
-            }
-            writeLine(stderr, message);
-        },
-        error: (message) => {
-            writeLine(stderr, message);
-        },
-    };
-};

package/dist/lib/prompt-secret.js

@@ -1,32 +0,0 @@
-import { createInterface } from 'node:readline/promises';
-import { Writable } from 'node:stream';
-export const createPromptSecret = ({ input = process.stdin, output = process.stderr, } = {}) => {
-    return async (message) => {
-        let muted = false;
-        const maskedOutput = new Writable({
-            write(chunk, encoding, callback) {
-                if (!muted) {
-                    output.write(chunk, encoding);
-                }
-                callback();
-            },
-        });
-        const readline = createInterface({
-            input,
-            output: maskedOutput,
-            terminal: true,
-        });
-        try {
-            output.write(message);
-            muted = true;
-            const value = await readline.question('');
-            muted = false;
-            output.write('\n');
-            return value.trim();
-        }
-        finally {
-            muted = false;
-            readline.close();
-        }
-    };
-};

package/dist/lib/session.js

@@ -1,72 +0,0 @@
-import { createApiClient } from './api-client.js';
-import { CliCommandError } from './cli-error.js';
-import { chalksurfBaseUrlEnvVar, chalksurfOrganizationIdEnvVar, chalksurfTokenEnvVar, resolveBaseUrl, resolveToken, } from './config-store.js';
-const normalizeOptionalString = (value) => {
-    const trimmedValue = value?.trim();
-    return trimmedValue ? trimmedValue : undefined;
-};
-export const mapApiErrorToCliError = (error) => {
-    const message = error instanceof Error ? error.message : 'Unknown API error';
-    if (message.includes('UNAUTHORIZED')) {
-        return new CliCommandError('Authentication failed. The CLI token is invalid or revoked.', 3);
-    }
-    return new CliCommandError(`API request failed: ${message}`, 5);
-};
-export const requireResolvedBaseUrl = ({ flagValue, env, config, }) => {
-    const resolvedBaseUrl = resolveBaseUrl({ flagValue, env, config });
-    if (!resolvedBaseUrl.value) {
-        throw new CliCommandError(`Missing ChalkSurf base URL. Pass --base-url, set ${chalksurfBaseUrlEnvVar}, or log in first.`, 2);
-    }
-    return resolvedBaseUrl;
-};
-export const requireResolvedToken = ({ env, config, }) => {
-    const resolvedToken = resolveToken({ env, config });
-    if (!resolvedToken.value) {
-        throw new CliCommandError(`Not authenticated. Set ${chalksurfTokenEnvVar} or run "chalksurf auth login".`, 3);
-    }
-    return resolvedToken;
-};
-export const resolveRequestedOrganizationId = ({ config, env, fallbackValue, flagValue, }) => {
-    return (normalizeOptionalString(flagValue) ??
-        normalizeOptionalString(fallbackValue) ??
-        normalizeOptionalString(env[chalksurfOrganizationIdEnvVar]) ??
-        normalizeOptionalString(config.organizationId));
-};
-export const createResolvedApiClient = async ({ context, baseUrlFlagValue, organizationFallbackValue, organizationFlagValue, profileName, }) => {
-    const config = await context.configStore.loadProfile({ profileName });
-    const resolvedBaseUrl = requireResolvedBaseUrl({
-        flagValue: baseUrlFlagValue,
-        env: context.env,
-        config,
-    });
-    const resolvedToken = requireResolvedToken({
-        env: context.env,
-        config,
-    });
-    const organizationId = resolveRequestedOrganizationId({
-        flagValue: organizationFlagValue,
-        fallbackValue: organizationFallbackValue,
-        env: context.env,
-        config,
-    });
-    return {
-        apiClient: createApiClient({
-            baseUrl: resolvedBaseUrl.value,
-            token: resolvedToken.value,
-            organizationId,
-        }),
-        organizationId,
-    };
-};
-export const formatUserIdentity = (profile) => {
-    if (profile.name && profile.email) {
-        return `${profile.name} <${profile.email}>`;
-    }
-    if (profile.email) {
-        return profile.email;
-    }
-    if (profile.name) {
-        return profile.name;
-    }
-    return profile.id;
-};