@anydocs/core 1.0.0

package/dist/services/workflow-standard-service.js

@@ -0,0 +1,372 @@
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { ValidationError } from "../errors/validation-error.js";
+import { PAGE_STATUSES } from "../types/docs.js";
+function relativeToRepo(contract, targetPath) {
+    return path.relative(contract.paths.repoRoot, targetPath) || '.';
+}
+function createSourceFiles(contract) {
+    const files = [
+        {
+            id: 'projectConfig',
+            path: relativeToRepo(contract, contract.paths.configFile),
+            format: 'json',
+            required: true,
+            writable: true,
+            generated: false,
+            description: 'Canonical project configuration for authoring, build, and preview.',
+        },
+        {
+            id: 'workflowStandard',
+            path: relativeToRepo(contract, contract.paths.workflowFile),
+            format: 'json',
+            required: true,
+            writable: true,
+            generated: false,
+            description: 'Reusable workflow contract for external automation and future AI-native flows.',
+        },
+    ];
+    for (const language of contract.config.languages) {
+        const roots = contract.paths.languageRoots[language];
+        files.push({
+            id: 'navigation',
+            path: relativeToRepo(contract, roots.navigationFile),
+            format: 'json',
+            required: true,
+            writable: true,
+            generated: false,
+            description: `Navigation tree for ${language}.`,
+        });
+        files.push({
+            id: 'page',
+            path: relativeToRepo(contract, path.join(roots.pagesDir, '{pageId}.json')),
+            format: 'json',
+            required: true,
+            writable: true,
+            generated: false,
+            description: `Page document pattern for ${language}.`,
+        });
+    }
+    files.push({
+        id: 'apiSource',
+        path: relativeToRepo(contract, path.join(contract.paths.apiSourcesRoot, '{sourceId}.json')),
+        format: 'json',
+        required: false,
+        writable: true,
+        generated: false,
+        description: 'API source document pattern for OpenAPI-backed reference surfaces.',
+    });
+    return files;
+}
+function createGeneratedArtifacts(contract) {
+    const artifacts = [
+        {
+            id: 'llms',
+            path: relativeToRepo(contract, contract.paths.llmsFile),
+            format: 'text',
+            required: false,
+            writable: false,
+            generated: true,
+            description: 'AI-friendly published artifact generated from published content only.',
+        },
+        {
+            id: 'llmsFull',
+            path: relativeToRepo(contract, path.join(contract.paths.artifactRoot, 'llms-full.txt')),
+            format: 'text',
+            required: false,
+            writable: false,
+            generated: true,
+            description: 'Full-site AI-readable fallback export generated from published content only.',
+        },
+        {
+            id: 'machineReadableRoot',
+            path: relativeToRepo(contract, contract.paths.machineReadableRoot),
+            format: 'directory',
+            required: false,
+            writable: false,
+            generated: true,
+            description: 'Machine-readable published artifacts generated from canonical publication rules.',
+        },
+        {
+            id: 'machineReadableIndex',
+            path: relativeToRepo(contract, path.join(contract.paths.machineReadableRoot, 'index.json')),
+            format: 'json',
+            required: false,
+            writable: false,
+            generated: true,
+            description: 'Stable machine-readable artifact index for external AI and automation consumers.',
+        },
+        {
+            id: 'openApiRoot',
+            path: relativeToRepo(contract, path.join(contract.paths.machineReadableRoot, 'openapi')),
+            format: 'directory',
+            required: false,
+            writable: false,
+            generated: true,
+            description: 'Machine-readable OpenAPI artifacts generated from published api sources.',
+        },
+    ];
+    for (const language of contract.config.languages) {
+        artifacts.push({
+            id: 'openApiIndex',
+            path: relativeToRepo(contract, path.join(contract.paths.machineReadableRoot, 'openapi', `index.${language}.json`)),
+            format: 'json',
+            required: false,
+            writable: false,
+            generated: true,
+            description: `Machine-readable OpenAPI source index for ${language}.`,
+        });
+        artifacts.push({
+            id: 'searchIndex',
+            path: relativeToRepo(contract, contract.paths.languageRoots[language].searchIndexFile),
+            format: 'json',
+            required: false,
+            writable: false,
+            generated: true,
+            description: `Static search index for ${language}.`,
+        });
+        artifacts.push({
+            id: 'chunkIndex',
+            path: relativeToRepo(contract, path.join(contract.paths.machineReadableRoot, `chunks.${language}.json`)),
+            format: 'json',
+            required: false,
+            writable: false,
+            generated: true,
+            description: `Machine-readable chunk artifact for ${language}.`,
+        });
+    }
+    return artifacts;
+}
+function createWorkflowValidationError(rule, remediation, metadata) {
+    return new ValidationError(`Workflow standard validation failed for rule "${rule}".`, {
+        entity: 'workflow-standard',
+        rule,
+        remediation,
+        metadata,
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertStringArray(value, rule, remediation) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string' || entry.trim().length === 0)) {
+        throw createWorkflowValidationError(rule, remediation, { received: value });
+    }
+}
+export function validateWorkflowStandardDefinition(input) {
+    if (!isRecord(input)) {
+        throw createWorkflowValidationError('workflow-standard-object', 'Ensure anydocs.workflow.json contains a JSON object matching the canonical workflow standard definition.', { received: input });
+    }
+    if (input.version !== 1) {
+        throw createWorkflowValidationError('workflow-standard-version', 'Regenerate anydocs.workflow.json with the current anydocs init or workflow export logic.', { received: input.version });
+    }
+    if (input.standardId !== 'anydocs-phase-1') {
+        throw createWorkflowValidationError('workflow-standard-id', 'Use the canonical anydocs-phase-1 workflow standard id.', { received: input.standardId });
+    }
+    if (input.projectContractVersion !== 1) {
+        throw createWorkflowValidationError('workflow-standard-project-contract-version', 'Use a workflow standard generated from the current project contract version.', { received: input.projectContractVersion });
+    }
+    if (input.localFirst !== true || input.uiIndependent !== true) {
+        throw createWorkflowValidationError('workflow-standard-core-flags', 'Preserve localFirst and uiIndependent as true for the phase 1 workflow standard.', { localFirst: input.localFirst, uiIndependent: input.uiIndependent });
+    }
+    assertStringArray(input.supportedLanguages, 'workflow-standard-supported-languages', 'List supported languages as non-empty string identifiers in anydocs.workflow.json.');
+    assertStringArray(input.enabledLanguages, 'workflow-standard-enabled-languages', 'List enabled languages as non-empty string identifiers in anydocs.workflow.json.');
+    assertStringArray(input.publicationStatuses, 'workflow-standard-publication-statuses', 'List publication statuses as non-empty string identifiers in anydocs.workflow.json.');
+    assertStringArray(input.publishedStatuses, 'workflow-standard-published-statuses', 'List published statuses as non-empty string identifiers in anydocs.workflow.json.');
+    if (!Array.isArray(input.sourceFiles) || input.sourceFiles.some((file) => !isRecord(file))) {
+        throw createWorkflowValidationError('workflow-standard-source-files', 'Define sourceFiles as an array of workflow standard file descriptors.', { received: input.sourceFiles });
+    }
+    if (!Array.isArray(input.generatedArtifacts) || input.generatedArtifacts.some((file) => !isRecord(file))) {
+        throw createWorkflowValidationError('workflow-standard-generated-artifacts', 'Define generatedArtifacts as an array of workflow standard file descriptors.', { received: input.generatedArtifacts });
+    }
+    if (!isRecord(input.contentModel)) {
+        throw createWorkflowValidationError('workflow-standard-content-model', 'Define contentModel as an object describing config, page, and navigation fields.', { received: input.contentModel });
+    }
+    assertStringArray(input.contentModel.projectConfigFields, 'workflow-standard-project-config-fields', 'List projectConfigFields as strings in the workflow standard content model.');
+    assertStringArray(input.contentModel.pageRequiredFields, 'workflow-standard-page-required-fields', 'List pageRequiredFields as strings in the workflow standard content model.');
+    assertStringArray(input.contentModel.pageOptionalFields, 'workflow-standard-page-optional-fields', 'List pageOptionalFields as strings in the workflow standard content model.');
+    assertStringArray(input.contentModel.navigationRequiredFields, 'workflow-standard-navigation-required-fields', 'List navigationRequiredFields as strings in the workflow standard content model.');
+    if (!isRecord(input.orchestration)) {
+        throw createWorkflowValidationError('workflow-standard-orchestration', 'Define orchestration as an object containing workflow steps and compatibility flags.', { received: input.orchestration });
+    }
+    assertStringArray(input.orchestration.workflowSteps, 'workflow-standard-workflow-steps', 'List orchestration.workflowSteps as strings in the canonical order.');
+    if (input.orchestration.publicationRule !== 'published-only') {
+        throw createWorkflowValidationError('workflow-standard-publication-rule', 'Use the canonical published-only publication rule in the workflow standard.', { received: input.orchestration.publicationRule });
+    }
+    if (input.orchestration.futureCompatibleWithoutReinitialization !== true ||
+        input.orchestration.externalAutomationReady !== true) {
+        throw createWorkflowValidationError('workflow-standard-compatibility-flags', 'Preserve futureCompatibleWithoutReinitialization and externalAutomationReady as true in the workflow standard.', {
+            futureCompatibleWithoutReinitialization: input.orchestration.futureCompatibleWithoutReinitialization,
+            externalAutomationReady: input.orchestration.externalAutomationReady,
+        });
+    }
+    return input;
+}
+function toComparableWorkflowFile(file) {
+    return {
+        id: file.id,
+        path: file.path,
+        format: file.format,
+        required: file.required,
+        writable: file.writable,
+        generated: file.generated,
+        description: file.description,
+    };
+}
+function toComparableWorkflowDefinition(definition) {
+    return {
+        version: definition.version,
+        standardId: definition.standardId,
+        projectContractVersion: definition.projectContractVersion,
+        localFirst: definition.localFirst,
+        uiIndependent: definition.uiIndependent,
+        supportedLanguages: definition.supportedLanguages,
+        enabledLanguages: definition.enabledLanguages,
+        publicationStatuses: definition.publicationStatuses,
+        publishedStatuses: definition.publishedStatuses,
+        sourceFiles: definition.sourceFiles.map(toComparableWorkflowFile),
+        // Note: generatedArtifacts paths are excluded from comparison because they depend on
+        // the build output directory, which can be customized via CLI --output or config.
+        // We only validate source files and configuration.
+        contentModel: definition.contentModel,
+        orchestration: definition.orchestration,
+    };
+}
+function createWorkflowFileKey(file) {
+    return `${file.id}:${file.path}`;
+}
+function hasCompatibleSourceFiles(persisted, expected) {
+    const persistedByKey = new Map(persisted.map((file) => [createWorkflowFileKey(file), file]));
+    for (const expectedFile of expected) {
+        const persistedFile = persistedByKey.get(createWorkflowFileKey(expectedFile));
+        if (!persistedFile) {
+            if (expectedFile.required) {
+                return false;
+            }
+            continue;
+        }
+        if (JSON.stringify(persistedFile) !== JSON.stringify(expectedFile)) {
+            return false;
+        }
+    }
+    return true;
+}
+export async function readWorkflowStandardDefinition(workflowFile) {
+    const raw = await readFile(workflowFile, 'utf8').catch(() => {
+        throw createWorkflowValidationError('workflow-standard-file-readable', 'Ensure anydocs.workflow.json exists and is readable before validating workflow compatibility.', { workflowFile });
+    });
+    try {
+        return validateWorkflowStandardDefinition(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error instanceof ValidationError) {
+            throw error;
+        }
+        throw createWorkflowValidationError('workflow-standard-json-valid', 'Fix anydocs.workflow.json so it contains valid JSON before validating workflow compatibility.', {
+            workflowFile,
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+export function assertWorkflowStandardMatchesContract(definition, contract) {
+    const expected = createWorkflowStandardDefinition(contract);
+    const comparablePersisted = toComparableWorkflowDefinition(definition);
+    const comparableExpected = toComparableWorkflowDefinition(expected);
+    const comparablePersistedCore = {
+        ...comparablePersisted,
+        sourceFiles: undefined,
+    };
+    const comparableExpectedCore = {
+        ...comparableExpected,
+        sourceFiles: undefined,
+    };
+    if (JSON.stringify(comparablePersistedCore) !== JSON.stringify(comparableExpectedCore) ||
+        !hasCompatibleSourceFiles(comparablePersisted.sourceFiles, comparableExpected.sourceFiles)) {
+        throw createWorkflowValidationError('workflow-standard-matches-project-contract', 'Regenerate anydocs.workflow.json so its languages, file paths, and publication rules match the current canonical project contract.', {
+            expected: comparableExpected,
+            received: comparablePersisted,
+        });
+    }
+}
+export function createWorkflowStandardDefinition(contract) {
+    return {
+        version: 1,
+        standardId: 'anydocs-phase-1',
+        projectContractVersion: contract.config.version,
+        localFirst: true,
+        uiIndependent: true,
+        supportedLanguages: ['zh', 'en'],
+        enabledLanguages: contract.config.languages,
+        publicationStatuses: [...PAGE_STATUSES],
+        publishedStatuses: ['published'],
+        sourceFiles: createSourceFiles(contract),
+        generatedArtifacts: createGeneratedArtifacts(contract),
+        contentModel: {
+            projectConfigFields: ['version', 'projectId', 'name', 'defaultLanguage', 'languages', 'site', 'build'],
+            pageRequiredFields: ['id', 'lang', 'slug', 'title', 'status', 'content'],
+            pageOptionalFields: ['description', 'tags', 'updatedAt', 'render'],
+            navigationRequiredFields: ['version', 'items'],
+        },
+        orchestration: {
+            workflowSteps: [
+                'loadConfig',
+                'loadContent',
+                'validate',
+                'persistSources',
+                'filterPublished',
+                'generateArtifacts',
+                'reportResult',
+            ],
+            publicationRule: 'published-only',
+            futureCompatibleWithoutReinitialization: true,
+            externalAutomationReady: true,
+        },
+    };
+}
+export function renderWorkflowStandardGuide(definition) {
+    const sourceFiles = definition.sourceFiles
+        .map((file) => `- ${file.path} (${file.description})`)
+        .join('\n');
+    const generatedArtifacts = definition.generatedArtifacts
+        .map((file) => `- ${file.path} (${file.description})`)
+        .join('\n');
+    const workflowSteps = definition.orchestration.workflowSteps.map((step) => `- ${step}`).join('\n');
+    return [
+        '# Anydocs Workflow Standard',
+        '',
+        `Standard ID: ${definition.standardId}`,
+        `Project Contract Version: ${definition.projectContractVersion}`,
+        `Local First: ${definition.localFirst ? 'yes' : 'no'}`,
+        `UI Independent: ${definition.uiIndependent ? 'yes' : 'no'}`,
+        `Enabled Languages: ${definition.enabledLanguages.join(', ')}`,
+        `Publication Statuses: ${definition.publicationStatuses.join(', ')}`,
+        `Published Output Rule: ${definition.orchestration.publicationRule}`,
+        '',
+        '## Source Files',
+        sourceFiles,
+        '',
+        '## Generated Artifacts',
+        generatedArtifacts,
+        '',
+        '## Content Model',
+        `- Project config fields: ${definition.contentModel.projectConfigFields.join(', ')}`,
+        `- Page required fields: ${definition.contentModel.pageRequiredFields.join(', ')}`,
+        `- Page optional fields: ${definition.contentModel.pageOptionalFields.join(', ')}`,
+        `- Navigation required fields: ${definition.contentModel.navigationRequiredFields.join(', ')}`,
+        '',
+        '## Workflow Steps',
+        workflowSteps,
+        '',
+        '## Compatibility Rules',
+        '- Future automation may create or modify source files directly as long as it preserves the same config, page, and navigation schemas.',
+        '- No project reinitialization is required when later workflows reuse this standard.',
+        '- Generated artifacts must not be edited by hand.',
+    ].join('\n');
+}
+export function exportWorkflowStandard(contract) {
+    const definition = createWorkflowStandardDefinition(contract);
+    return {
+        definition,
+        markdownGuide: renderWorkflowStandardGuide(definition),
+    };
+}

package/dist/types/api-source.d.ts

@@ -0,0 +1,34 @@
+import type { DocsLang } from './docs.ts';
+export declare const API_SOURCE_TYPES: readonly ["openapi"];
+export type ApiSourceType = (typeof API_SOURCE_TYPES)[number];
+export declare const API_SOURCE_STATUSES: readonly ["draft", "published"];
+export type ApiSourceStatus = (typeof API_SOURCE_STATUSES)[number];
+export type ApiSourceInput = {
+    kind: 'url';
+    url: string;
+} | {
+    kind: 'file';
+    path: string;
+};
+export type ApiSourceDisplay = {
+    title: string;
+    groupId?: string;
+};
+export type ApiSourceRuntime = {
+    routeBase?: string;
+    tryIt?: {
+        enabled: boolean;
+    };
+};
+export type ApiSourceDoc = {
+    id: string;
+    type: ApiSourceType;
+    lang: DocsLang;
+    status: ApiSourceStatus;
+    source: ApiSourceInput;
+    display: ApiSourceDisplay;
+    runtime?: ApiSourceRuntime;
+};
+export declare function isApiSourceType(value: unknown): value is ApiSourceType;
+export declare function isApiSourceStatus(value: unknown): value is ApiSourceStatus;
+//# sourceMappingURL=api-source.d.ts.map

package/dist/types/api-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-source.d.ts","sourceRoot":"","sources":["../../src/types/api-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C,eAAO,MAAM,gBAAgB,sBAAuB,CAAC;AACrD,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D,eAAO,MAAM,mBAAmB,iCAAkC,CAAC;AACnE,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnE,MAAM,MAAM,cAAc,GACtB;IACE,IAAI,EAAE,KAAK,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE;QACN,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,eAAe,CAAC;IACxB,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE1E"}

package/dist/types/api-source.js

@@ -0,0 +1,8 @@
+export const API_SOURCE_TYPES = ['openapi'];
+export const API_SOURCE_STATUSES = ['draft', 'published'];
+export function isApiSourceType(value) {
+    return typeof value === 'string' && API_SOURCE_TYPES.includes(value);
+}
+export function isApiSourceStatus(value) {
+    return typeof value === 'string' && API_SOURCE_STATUSES.includes(value);
+}

package/dist/types/docs.d.ts

@@ -0,0 +1,65 @@
+export declare const DOCS_LANGUAGES: readonly ["zh", "en"];
+export type DocsLang = (typeof DOCS_LANGUAGES)[number];
+export declare const PAGE_STATUSES: readonly ["draft", "in_review", "published"];
+export type PageStatus = (typeof PAGE_STATUSES)[number];
+export type PageRender = {
+    markdown?: string;
+    plainText?: string;
+};
+export type PageReviewWarning = {
+    code: string;
+    message: string;
+    remediation?: string;
+    metadata?: Record<string, unknown>;
+};
+export type PageReviewSourceType = 'legacy-import' | 'ai-generated';
+export type PageReview = {
+    required: boolean;
+    sourceType: PageReviewSourceType;
+    sourceId: string;
+    itemId?: string;
+    sourcePath?: string;
+    approvedAt?: string;
+    metadata?: Record<string, unknown>;
+    warnings?: PageReviewWarning[];
+};
+export type PageDoc<TContent = unknown> = {
+    id: string;
+    lang: DocsLang;
+    slug: string;
+    title: string;
+    description?: string;
+    tags?: string[];
+    status: PageStatus;
+    updatedAt?: string;
+    content: TContent;
+    render?: PageRender;
+    review?: PageReview;
+};
+export type NavItem = {
+    type: 'section';
+    id?: string;
+    title: string;
+    children: NavItem[];
+} | {
+    type: 'folder';
+    id?: string;
+    title: string;
+    children: NavItem[];
+} | {
+    type: 'page';
+    pageId: string;
+    titleOverride?: string;
+    hidden?: boolean;
+} | {
+    type: 'link';
+    title: string;
+    href: string;
+};
+export type NavigationDoc = {
+    version: number;
+    items: NavItem[];
+};
+export declare function isDocsLang(value: unknown): value is DocsLang;
+export declare function isPageStatus(value: unknown): value is PageStatus;
+//# sourceMappingURL=docs.d.ts.map

package/dist/types/docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/types/docs.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,uBAAwB,CAAC;AAEpD,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,eAAO,MAAM,aAAa,8CAA+C,CAAC;AAE1E,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG,cAAc,CAAC;AAEpE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,oBAAoB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,iBAAiB,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,OAAO,CAAC,QAAQ,GAAG,OAAO,IAAI;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,OAAO,GACf;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AAEF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}

package/dist/types/docs.js

@@ -0,0 +1,8 @@
+export const DOCS_LANGUAGES = ['zh', 'en'];
+export const PAGE_STATUSES = ['draft', 'in_review', 'published'];
+export function isDocsLang(value) {
+    return typeof value === 'string' && DOCS_LANGUAGES.includes(value);
+}
+export function isPageStatus(value) {
+    return typeof value === 'string' && PAGE_STATUSES.includes(value);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api-source.ts';
+export * from './docs.ts';
+export * from './legacy-import.ts';
+export * from './project.ts';
+export * from './workflow-standard.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,wBAAwB,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,5 @@
+export * from "./api-source.js";
+export * from "./docs.js";
+export * from "./legacy-import.js";
+export * from "./project.js";
+export * from "./workflow-standard.js";

package/dist/types/legacy-import.d.ts

@@ -0,0 +1,72 @@
+import type { DocsLanguage } from './project.ts';
+export type LegacyImportFormat = 'markdown' | 'mdx';
+export type LegacyImportStatus = 'staged' | 'converted';
+export type LegacyImportFrontmatterValue = string | string[];
+export type LegacyImportWarning = {
+    itemId?: string;
+    code: string;
+    message: string;
+    remediation?: string;
+    metadata?: Record<string, unknown>;
+};
+export type LegacyImportItem = {
+    id: string;
+    sourcePath: string;
+    lang: DocsLanguage;
+    slug: string;
+    title: string;
+    description?: string;
+    tags?: string[];
+    format: LegacyImportFormat;
+    importedAt: string;
+    rawContent: string;
+    body: string;
+    frontmatter: Record<string, LegacyImportFrontmatterValue>;
+    status: LegacyImportStatus;
+    convertedAt?: string;
+};
+export type LegacyImportManifestItem = Pick<LegacyImportItem, 'id' | 'sourcePath' | 'lang' | 'slug' | 'title' | 'format' | 'status'>;
+export type LegacyImportManifest = {
+    version: 1;
+    importId: string;
+    projectId: string;
+    sourceRoot: string;
+    importedAt: string;
+    itemCount: number;
+    status: LegacyImportStatus;
+    items: LegacyImportManifestItem[];
+};
+export type LegacyImportResult = {
+    importId: string;
+    importRoot: string;
+    manifestFile: string;
+    itemCount: number;
+    items: LegacyImportManifestItem[];
+};
+export type LegacyImportConversionItem = {
+    itemId: string;
+    pageId: string;
+    lang: DocsLanguage;
+    slug: string;
+    status: 'draft';
+    warnings: LegacyImportWarning[];
+};
+export type LegacyImportConversionReport = {
+    version: 1;
+    importId: string;
+    projectId: string;
+    convertedAt: string;
+    status: 'converted';
+    convertedCount: number;
+    items: LegacyImportConversionItem[];
+    warnings: LegacyImportWarning[];
+};
+export type LegacyImportConversionResult = {
+    importId: string;
+    importRoot: string;
+    reportFile: string;
+    convertedCount: number;
+    items: LegacyImportConversionItem[];
+    warnings: LegacyImportWarning[];
+};
+//# sourceMappingURL=legacy-import.d.ts.map

package/dist/types/legacy-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-import.d.ts","sourceRoot":"","sources":["../../src/types/legacy-import.ts"],"names":[],"mappings":"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"}

package/dist/types/legacy-import.js

@@ -0,0 +1 @@
+export {};