@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/sdd/types.d.ts

@@ -527,6 +527,19 @@ export declare const SkillCatalogEntrySchema: z.ZodObject<{
     tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
     bundle_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
     priority: z.ZodDefault<z.ZodNumber>;
+    token_budget: z.ZodDefault<z.ZodObject<{
+        input_max: z.ZodNumber;
+        output_max: z.ZodNumber;
+        thinking_max: z.ZodNumber;
+    }, z.core.$strip>>;
+    integrity_hash: z.ZodDefault<z.ZodString>;
+    deterministic_pair: z.ZodOptional<z.ZodObject<{
+        plugin_id: z.ZodString;
+        capability: z.ZodOptional<z.ZodString>;
+        operation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    deprecated_at: z.ZodOptional<z.ZodString>;
+    superseded_by: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const SkillBundleSchema: z.ZodObject<{
     id: z.ZodString;
@@ -646,8 +659,8 @@ export declare const ControlCatalogItemSchema: z.ZodObject<{
     }>>;
     automatable: z.ZodDefault<z.ZodEnum<{
         yes: "yes";
-        partial: "partial";
         no: "no";
+        partial: "partial";
     }>>;
     verification_types: z.ZodDefault<z.ZodArray<z.ZodString>>;
     jurisdiction_profile_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -1137,6 +1150,19 @@ export declare const SkillCatalogStateSchema: z.ZodObject<{
         tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
         bundle_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
         priority: z.ZodDefault<z.ZodNumber>;
+        token_budget: z.ZodDefault<z.ZodObject<{
+            input_max: z.ZodNumber;
+            output_max: z.ZodNumber;
+            thinking_max: z.ZodNumber;
+        }, z.core.$strip>>;
+        integrity_hash: z.ZodDefault<z.ZodString>;
+        deterministic_pair: z.ZodOptional<z.ZodObject<{
+            plugin_id: z.ZodString;
+            capability: z.ZodOptional<z.ZodString>;
+            operation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        deprecated_at: z.ZodOptional<z.ZodString>;
+        superseded_by: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     bundles: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -1245,8 +1271,8 @@ export declare const SourceIndexStateSchema: z.ZodObject<{
         }>>;
         automatable: z.ZodDefault<z.ZodEnum<{
             yes: "yes";
-            partial: "partial";
             no: "no";
+            partial: "partial";
         }>>;
         verification_types: z.ZodDefault<z.ZodArray<z.ZodString>>;
         jurisdiction_profile_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -1375,10 +1401,10 @@ export declare const RepoMapStateSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export declare const NamingContractTermScopeSchema: z.ZodEnum<{
+    state: "state";
     all: "all";
     code: "code";
     docs: "docs";
-    state: "state";
 }>;
 export declare const NamingContractTermSeveritySchema: z.ZodEnum<{
     error: "error";
@@ -1387,10 +1413,10 @@ export declare const NamingContractTermSeveritySchema: z.ZodEnum<{
 export declare const NamingContractForbiddenTermSchema: z.ZodObject<{
     term: z.ZodString;
     scope: z.ZodDefault<z.ZodEnum<{
+        state: "state";
         all: "all";
         code: "code";
         docs: "docs";
-        state: "state";
     }>>;
     severity: z.ZodDefault<z.ZodEnum<{
         error: "error";
@@ -1418,10 +1444,10 @@ export declare const NamingContractRenameRuleSchema: z.ZodObject<{
     from: z.ZodString;
     to: z.ZodString;
     scope: z.ZodDefault<z.ZodEnum<{
+        state: "state";
         all: "all";
         code: "code";
         docs: "docs";
-        state: "state";
     }>>;
     phase: z.ZodString;
     owner: z.ZodString;
@@ -1460,10 +1486,10 @@ export declare const NamingContractStateSchema: z.ZodObject<{
     forbidden_terms: z.ZodDefault<z.ZodArray<z.ZodObject<{
         term: z.ZodString;
         scope: z.ZodDefault<z.ZodEnum<{
+            state: "state";
             all: "all";
             code: "code";
             docs: "docs";
-            state: "state";
         }>>;
         severity: z.ZodDefault<z.ZodEnum<{
             error: "error";
@@ -1481,10 +1507,10 @@ export declare const NamingContractStateSchema: z.ZodObject<{
         from: z.ZodString;
         to: z.ZodString;
         scope: z.ZodDefault<z.ZodEnum<{
+            state: "state";
             all: "all";
             code: "code";
             docs: "docs";
-            state: "state";
         }>>;
         phase: z.ZodString;
         owner: z.ZodString;

package/dist/core/sdd/types.js

@@ -300,6 +300,23 @@ export const SkillCatalogEntrySchema = z.object({
     tools: StringArraySchema,
     bundle_ids: StringArraySchema,
     priority: z.number().int().nonnegative().default(0),
+    token_budget: z
+        .object({
+        input_max: z.number().int().positive(),
+        output_max: z.number().int().positive(),
+        thinking_max: z.number().int().nonnegative(),
+    })
+        .default({ input_max: 12000, output_max: 4000, thinking_max: 2000 }),
+    integrity_hash: z.string().regex(/^[a-f0-9]{64}$/).default('0000000000000000000000000000000000000000000000000000000000000000'),
+    deterministic_pair: z
+        .object({
+        plugin_id: z.string().min(1),
+        capability: z.string().min(1).optional(),
+        operation: z.string().min(1).optional(),
+    })
+        .optional(),
+    deprecated_at: z.string().datetime().optional(),
+    superseded_by: z.string().min(1).optional(),
 });
 export const SkillBundleSchema = z.object({
     id: z.string().min(1),

package/dist/core/sdd/upgrade-to-codesdd.d.ts

@@ -0,0 +1,45 @@
+import { type SddMigrationAssessment } from './migrate.js';
+import { buildSddContractConfig } from './contract.js';
+export interface UpgradeToCodeSddReadinessReport {
+    status: 'ready' | 'needs-upgrade' | 'blocked';
+    assessment: SddMigrationAssessment;
+    blockers: string[];
+    warnings: string[];
+    planned_steps: string[];
+}
+export interface UpgradeToCodeSddManifest {
+    manifest_version: 1;
+    transaction_id: string;
+    mode: 'apply';
+    created_at: string;
+    readiness: UpgradeToCodeSddReadinessReport;
+    backup_root: string;
+    backed_up_paths: string[];
+    migration_messages: string[];
+    sdd_contract: ReturnType<typeof buildSddContractConfig>;
+}
+export interface UpgradeToCodeSddResult {
+    mode: 'dry-run' | 'apply';
+    readiness: UpgradeToCodeSddReadinessReport;
+    manifest?: UpgradeToCodeSddManifest;
+    manifest_path?: string;
+}
+export interface UpgradeToCodeSddRollbackResult {
+    transaction_id: string;
+    restored_paths: string[];
+    skipped_paths: string[];
+    manifest_path: string;
+    reason: string;
+}
+export declare class UpgradeToCodeSddCommand {
+    execute(projectRoot: string, options?: {
+        dryRun?: boolean;
+        apply?: boolean;
+        yes?: boolean;
+    }): Promise<UpgradeToCodeSddResult>;
+    rollback(projectRoot: string, transactionId: string, options?: {
+        reason?: string;
+    }): Promise<UpgradeToCodeSddRollbackResult>;
+}
+export declare function formatUpgradeToCodeSddReadiness(report: UpgradeToCodeSddReadinessReport): string;
+//# sourceMappingURL=upgrade-to-codesdd.d.ts.map

package/dist/core/sdd/upgrade-to-codesdd.js

@@ -0,0 +1,179 @@
+import { createHash } from 'node:crypto';
+import { constants as fsConstants } from 'node:fs';
+import { access, cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { assessSddMigration, SddMigrateCommand } from './migrate.js';
+import { buildSddContractConfig } from './contract.js';
+function timestampToken(value = new Date()) {
+    return value.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
+}
+function createTransactionId(projectRoot, value = new Date()) {
+    const suffix = createHash('sha1').update(`${projectRoot}:${value.toISOString()}`).digest('hex').slice(0, 8).toUpperCase();
+    return `UPG-${timestampToken(value)}-${suffix}`;
+}
+async function pathExists(targetPath) {
+    try {
+        await access(targetPath, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function upgradeRoot(projectRoot) {
+    return path.join(projectRoot, '.sdd', 'reports', 'upgrade-to-codesdd');
+}
+function manifestPath(projectRoot, transactionId) {
+    return path.join(upgradeRoot(projectRoot), `${transactionId}-manifest.json`);
+}
+function backupRoot(projectRoot, transactionId) {
+    return path.join(upgradeRoot(projectRoot), transactionId, 'backups');
+}
+function backupCandidates(projectRoot) {
+    return [
+        '.sdd/config.yaml',
+        '.sdd/state',
+        '.sdd/active',
+        '.sdd/planned',
+        '.sdd/archived',
+    ].map((entry) => path.join(projectRoot, entry));
+}
+function toProjectRelative(projectRoot, targetPath) {
+    return path.relative(projectRoot, targetPath).replace(/\\/g, '/');
+}
+function backupDestination(projectRoot, root, targetPath) {
+    return path.join(root, toProjectRelative(projectRoot, targetPath));
+}
+async function writeJson(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+async function readJson(filePath) {
+    return JSON.parse(await readFile(filePath, 'utf-8'));
+}
+async function createBackups(projectRoot, transactionId) {
+    const root = backupRoot(projectRoot, transactionId);
+    const backedUp = [];
+    for (const candidate of backupCandidates(projectRoot)) {
+        if (!(await pathExists(candidate)))
+            continue;
+        const destination = backupDestination(projectRoot, root, candidate);
+        await mkdir(path.dirname(destination), { recursive: true });
+        await cp(candidate, destination, { recursive: true });
+        backedUp.push(toProjectRelative(projectRoot, candidate));
+    }
+    return backedUp;
+}
+function buildReadiness(assessment) {
+    const blockers = [];
+    if (assessment.currentVersion > assessment.targetVersion) {
+        blockers.push(`state_version=${assessment.currentVersion} is newer than supported target ${assessment.targetVersion}`);
+    }
+    const warnings = [...assessment.reasons];
+    const plannedSteps = [
+        'create transaction backup under .sdd/reports/upgrade-to-codesdd',
+        'run canonical SDD migration to CodeSDD state contract',
+        'write upgrade manifest with readiness and migration messages',
+        'allow rollback by transaction id while backup artifacts are present',
+    ];
+    return {
+        status: blockers.length > 0 ? 'blocked' : assessment.needsMigration ? 'needs-upgrade' : 'ready',
+        assessment,
+        blockers,
+        warnings,
+        planned_steps: plannedSteps,
+    };
+}
+export class UpgradeToCodeSddCommand {
+    async execute(projectRoot, options) {
+        const root = path.resolve(projectRoot);
+        const assessment = await assessSddMigration(root);
+        const readiness = buildReadiness(assessment);
+        if (!options?.apply || options.dryRun) {
+            return { mode: 'dry-run', readiness };
+        }
+        if (!options.yes) {
+            throw new Error('upgrade-to-codesdd apply requires --yes for transactional mutation.');
+        }
+        if (readiness.blockers.length > 0) {
+            throw new Error(`upgrade-to-codesdd blocked: ${readiness.blockers.join(' | ')}`);
+        }
+        const transactionId = createTransactionId(root);
+        const backedUpPaths = await createBackups(root, transactionId);
+        const migration = await new SddMigrateCommand().execute(root, { radToEpic: true });
+        const manifest = {
+            manifest_version: 1,
+            transaction_id: transactionId,
+            mode: 'apply',
+            created_at: new Date().toISOString(),
+            readiness,
+            backup_root: toProjectRelative(root, backupRoot(root, transactionId)),
+            backed_up_paths: backedUpPaths,
+            migration_messages: migration.messages,
+            sdd_contract: buildSddContractConfig(),
+        };
+        const manifestFile = manifestPath(root, transactionId);
+        await writeJson(manifestFile, manifest);
+        return {
+            mode: 'apply',
+            readiness,
+            manifest,
+            manifest_path: toProjectRelative(root, manifestFile),
+        };
+    }
+    async rollback(projectRoot, transactionId, options) {
+        const root = path.resolve(projectRoot);
+        if (!/^UPG-\d{8}T\d{6}Z-[A-F0-9]{8}$/.test(transactionId)) {
+            throw new Error('Invalid upgrade transaction id. Expected UPG-YYYYMMDDTHHMMSSZ-XXXXXXXX.');
+        }
+        const manifestFile = manifestPath(root, transactionId);
+        const manifest = await readJson(manifestFile);
+        const restoredPaths = [];
+        const skippedPaths = [];
+        for (const relativePath of manifest.backed_up_paths) {
+            const backupPath = path.join(root, manifest.backup_root, relativePath);
+            const targetPath = path.join(root, relativePath);
+            if (!(await pathExists(backupPath))) {
+                skippedPaths.push(relativePath);
+                continue;
+            }
+            await rm(targetPath, { recursive: true, force: true });
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await cp(backupPath, targetPath, { recursive: true });
+            restoredPaths.push(relativePath);
+        }
+        await writeJson(path.join(upgradeRoot(root), `${transactionId}-rollback.json`), {
+            transaction_id: transactionId,
+            rolled_back_at: new Date().toISOString(),
+            reason: options?.reason || 'Rollback requested.',
+            restored_paths: restoredPaths,
+            skipped_paths: skippedPaths,
+        });
+        return {
+            transaction_id: transactionId,
+            restored_paths: restoredPaths,
+            skipped_paths: skippedPaths,
+            manifest_path: toProjectRelative(root, manifestFile),
+            reason: options?.reason || 'Rollback requested.',
+        };
+    }
+}
+export function formatUpgradeToCodeSddReadiness(report) {
+    const lines = [
+        `Status: ${report.status}`,
+        `State version: ${report.assessment.currentVersion} -> ${report.assessment.targetVersion}`,
+        `Needs migration: ${report.assessment.needsMigration ? 'yes' : 'no'}`,
+    ];
+    if (report.blockers.length > 0) {
+        lines.push('Blockers:');
+        lines.push(...report.blockers.map((item) => `- ${item}`));
+    }
+    if (report.warnings.length > 0) {
+        lines.push('Warnings:');
+        lines.push(...report.warnings.map((item) => `- ${item}`));
+    }
+    lines.push('Planned steps:');
+    lines.push(...report.planned_steps.map((item) => `- ${item}`));
+    return lines.join('\n');
+}
+//# sourceMappingURL=upgrade-to-codesdd.js.map