@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/services/scan-naming.service.js

@@ -0,0 +1,246 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { loadProjectSddConfig, loadNamingContractState, resolveSddPaths, } from '../state.js';
+const execFileAsync = promisify(execFile);
+function formatIdentity(identity) {
+    return {
+        productName: identity.product_name,
+        cliBin: identity.cli_bin,
+        packageName: identity.package_name,
+    };
+}
+/**
+ * Convert a glob pattern (supporting **, *, ?) to a RegExp.
+ * Patterns are matched against POSIX-style relative file paths.
+ */
+function globToRegExp(pattern) {
+    let re = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                // ** matches across path separators
+                re += '.*';
+                i += 2;
+                if (pattern[i] === '/') {
+                    i += 1;
+                }
+                continue;
+            }
+            re += '[^/]*';
+            i += 1;
+            continue;
+        }
+        if (ch === '?') {
+            re += '[^/]';
+            i += 1;
+            continue;
+        }
+        if ('.+^$()|{}[]\\'.includes(ch)) {
+            re += '\\' + ch;
+            i += 1;
+            continue;
+        }
+        re += ch;
+        i += 1;
+    }
+    return new RegExp('^' + re + '$');
+}
+function matchesAny(filePath, patterns) {
+    if (patterns.length === 0)
+        return false;
+    const normalized = filePath.split(path.sep).join('/');
+    for (const pattern of patterns) {
+        if (globToRegExp(pattern).test(normalized)) {
+            return true;
+        }
+    }
+    return false;
+}
+function countOccurrences(haystack, needle) {
+    if (!needle)
+        return 0;
+    let count = 0;
+    let idx = 0;
+    while ((idx = haystack.indexOf(needle, idx)) !== -1) {
+        count += 1;
+        idx += needle.length;
+    }
+    return count;
+}
+function stricterSeverity(left, right) {
+    return left === 'error' || right === 'error' ? 'error' : 'warning';
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter(Boolean)));
+}
+function effectiveForbiddenTerms(contract) {
+    const byTerm = new Map();
+    for (const term of contract.forbidden_terms) {
+        byTerm.set(term.term, {
+            ...term,
+            allowlist_paths: uniqueStrings(term.allowlist_paths),
+        });
+    }
+    if (!contract.zero_residue_gate.enabled) {
+        return [...byTerm.values()];
+    }
+    for (const term of contract.zero_residue_gate.terms) {
+        const existing = byTerm.get(term);
+        if (existing) {
+            byTerm.set(term, {
+                ...existing,
+                severity: stricterSeverity(existing.severity, contract.zero_residue_gate.enforcement),
+                allowlist_paths: uniqueStrings([
+                    ...existing.allowlist_paths,
+                    ...contract.zero_residue_gate.allowlist_paths,
+                ]),
+            });
+            continue;
+        }
+        byTerm.set(term, {
+            term,
+            scope: 'all',
+            severity: contract.zero_residue_gate.enforcement,
+            allowlist_paths: uniqueStrings(contract.zero_residue_gate.allowlist_paths),
+        });
+    }
+    return [...byTerm.values()];
+}
+async function listGitTrackedFiles(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['ls-files'], {
+            cwd: projectRoot,
+            maxBuffer: 64 * 1024 * 1024,
+        });
+        return stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.bmp', '.tiff',
+    '.pdf', '.zip', '.tar', '.gz', '.bz2', '.xz', '.7z', '.rar',
+    '.woff', '.woff2', '.ttf', '.otf', '.eot',
+    '.mp3', '.mp4', '.mov', '.avi', '.wav', '.ogg',
+    '.exe', '.dll', '.so', '.dylib', '.bin', '.wasm',
+    '.lock',
+]);
+function shouldScanFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext))
+        return false;
+    return true;
+}
+function termAppliesToFile(_term, _filePath) {
+    // For now scope=all/code/docs/state are all scanned uniformly. Future: filter by scope.
+    return true;
+}
+export class ScanNamingService {
+    async execute(projectRoot, options) {
+        void options;
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        const contract = await loadNamingContractState(paths);
+        const tracked = await listGitTrackedFiles(projectRoot);
+        const candidateFiles = tracked.filter((file) => {
+            if (matchesAny(file, contract.allowlist.map((entry) => entry.path_pattern)))
+                return false;
+            return shouldScanFile(file);
+        });
+        const forbiddenTerms = effectiveForbiddenTerms(contract);
+        const violations = [];
+        let scannedFiles = 0;
+        for (const relativeFile of candidateFiles) {
+            const absolute = path.join(projectRoot, relativeFile);
+            let content;
+            try {
+                content = await fs.readFile(absolute, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            scannedFiles += 1;
+            for (const term of forbiddenTerms) {
+                if (!termAppliesToFile(term, relativeFile))
+                    continue;
+                if (matchesAny(relativeFile, term.allowlist_paths))
+                    continue;
+                const count = countOccurrences(content, term.term);
+                if (count > 0) {
+                    violations.push({
+                        file: relativeFile,
+                        term: term.term,
+                        count,
+                        severity: term.severity,
+                    });
+                }
+            }
+        }
+        const errorCount = violations.filter((v) => v.severity === 'error').length;
+        const warningCount = violations.filter((v) => v.severity === 'warning').length;
+        return {
+            scannedFiles,
+            violations,
+            errorCount,
+            warningCount,
+            contractVersion: contract.version,
+            contract: {
+                productName: contract.product_name,
+                cliBin: contract.cli_bin,
+                packageName: contract.package_name,
+                currentIdentity: formatIdentity(contract.current_identity),
+                targetIdentity: formatIdentity(contract.target_identity),
+                forbiddenTerms: forbiddenTerms.length,
+                allowlistEntries: contract.allowlist.length,
+                renameRules: contract.rename_rules.length,
+                zeroResidueGate: {
+                    enabled: contract.zero_residue_gate.enabled,
+                    enforcement: contract.zero_residue_gate.enforcement,
+                    terms: contract.zero_residue_gate.terms.length,
+                    removalPhase: contract.zero_residue_gate.removal_phase,
+                },
+            },
+        };
+    }
+}
+export function formatScanNamingReport(report) {
+    const lines = [];
+    lines.push(`Naming contract scan (version ${report.contractVersion})`);
+    lines.push(`  Product: ${report.contract.productName}`);
+    lines.push(`  CLI: ${report.contract.cliBin}`);
+    lines.push(`  Package: ${report.contract.packageName}`);
+    lines.push(`  Current identity: ${report.contract.currentIdentity.productName} / ${report.contract.currentIdentity.cliBin} / ${report.contract.currentIdentity.packageName}`);
+    lines.push(`  Target identity: ${report.contract.targetIdentity.productName} / ${report.contract.targetIdentity.cliBin} / ${report.contract.targetIdentity.packageName}`);
+    lines.push(`  Rename rules: ${report.contract.renameRules}`);
+    lines.push(`  Zero-residue gate: ${report.contract.zeroResidueGate.enabled ? 'enabled' : 'disabled'} (${report.contract.zeroResidueGate.enforcement}, ${report.contract.zeroResidueGate.terms} terms, removal phase: ${report.contract.zeroResidueGate.removalPhase})`);
+    lines.push(`Scanned files: ${report.scannedFiles}`);
+    lines.push(`Violations: ${report.violations.length} (errors=${report.errorCount}, warnings=${report.warningCount})`);
+    if (report.violations.length > 0) {
+        const byTerm = new Map();
+        for (const v of report.violations) {
+            byTerm.set(v.term, (byTerm.get(v.term) ?? 0) + v.count);
+        }
+        lines.push('By term:');
+        for (const [term, count] of [...byTerm.entries()].sort()) {
+            lines.push(`  ${term}: ${count} occurrences across ${report.violations.filter((v) => v.term === term).length} files`);
+        }
+        const sample = report.violations.slice(0, 10);
+        lines.push('Sample (first 10):');
+        for (const v of sample) {
+            lines.push(`  [${v.severity}] ${v.file} -> ${v.term} x${v.count}`);
+        }
+        if (report.violations.length > sample.length) {
+            lines.push(`  ... and ${report.violations.length - sample.length} more`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=scan-naming.service.js.map

package/dist/core/sdd/services/skills-invoke.service.d.ts

@@ -0,0 +1,24 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class SkillsInvokeService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, options?: {
+        ids?: string[];
+        phase?: string;
+        domains?: string[];
+        bundles?: string[];
+        max?: number;
+        objective?: string;
+        ref?: string;
+    }): Promise<{
+        selected_skills: {
+            id: string;
+            title: string;
+            bundles: string[];
+            path: string;
+            reason: string;
+        }[];
+        prompt: string;
+    }>;
+}
+//# sourceMappingURL=skills-invoke.service.d.ts.map

package/dist/core/sdd/services/skills-invoke.service.js

@@ -0,0 +1,63 @@
+import { suggestSkills } from "../skills.js";
+import { loadSkillCatalogState } from "../state.js";
+import { getRuntime, resolveSkillFileRef, buildSkillInvocationPrompt } from "../legacy-operations.js";
+export class SkillsInvokeService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, options) {
+        const { paths } = await getRuntime(projectRoot);
+        const catalog = await loadSkillCatalogState(paths);
+        const explicitIds = (options?.ids || []).map((id) => id.trim()).filter(Boolean);
+        const selectedEntries = [];
+        if (explicitIds.length > 0) {
+            const byId = new Map(catalog.skills.map((skill) => [skill.id, skill]));
+            for (const id of explicitIds) {
+                const skill = byId.get(id);
+                if (!skill) {
+                    throw new Error(`Skill nao encontrada no catalogo: ${id}`);
+                }
+                selectedEntries.push({ skill, reason: 'selecionada explicitamente' });
+            }
+        }
+        else {
+            const ranked = suggestSkills(catalog, {
+                phase: options?.phase,
+                domains: options?.domains,
+                bundles: options?.bundles,
+                max: options?.max ?? 5,
+            });
+            selectedEntries.push(...ranked.map((entry) => ({
+                skill: entry.skill,
+                reason: entry.reasons.join('; ') || 'sugerida por contexto',
+            })));
+        }
+        if (selectedEntries.length === 0) {
+            throw new Error('Nenhuma skill selecionada. Informe --ids ou ajuste filtros de sugestao.');
+        }
+        const selectedSkills = [];
+        for (const entry of selectedEntries) {
+            selectedSkills.push({
+                id: entry.skill.id,
+                title: entry.skill.title,
+                bundles: entry.skill.bundle_ids,
+                path: await resolveSkillFileRef(paths, entry.skill.id),
+                reason: entry.reason,
+            });
+        }
+        return {
+            selected_skills: selectedSkills,
+            prompt: buildSkillInvocationPrompt({
+                objective: options?.objective,
+                ref: options?.ref,
+                skills: selectedSkills.map((skill) => ({
+                    id: skill.id,
+                    path: skill.path,
+                    reason: skill.reason,
+                })),
+            }),
+        };
+    }
+}
+//# sourceMappingURL=skills-invoke.service.js.map

package/dist/core/sdd/services/skills-sync.service.d.ts

@@ -0,0 +1,15 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class SkillsSyncService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, options?: {
+        bundles?: string[];
+        all?: boolean;
+        tools?: string[];
+    }): Promise<{
+        synced: number;
+        local_synced: number;
+        tools: string[];
+    }>;
+}
+//# sourceMappingURL=skills-sync.service.d.ts.map

package/dist/core/sdd/services/skills-sync.service.js

@@ -0,0 +1,117 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { AI_TOOLS } from "../../config.js";
+import { loadSkillCatalogState } from "../state.js";
+import { getRuntime, buildCuratedSkillContent } from "../legacy-operations.js";
+import { SddWriteTransaction } from "../write-manifest.js";
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../');
+function isInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+async function readTextIfExists(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function localSourcePathCandidates(paths, sourcePath) {
+    const trimmed = sourcePath?.trim();
+    if (!trimmed || trimmed.includes('\0'))
+        return [];
+    const candidates = [];
+    if (path.isAbsolute(trimmed)) {
+        const absoluteCandidate = path.resolve(trimmed);
+        const projectRoot = path.resolve(paths.projectRoot);
+        if (isInside(projectRoot, absoluteCandidate) || isInside(PACKAGE_ROOT, absoluteCandidate)) {
+            candidates.push(absoluteCandidate);
+        }
+        return candidates;
+    }
+    const projectRoot = path.resolve(paths.projectRoot);
+    const projectCandidate = path.resolve(projectRoot, trimmed);
+    if (isInside(projectRoot, projectCandidate)) {
+        candidates.push(projectCandidate);
+    }
+    const packageCandidate = path.resolve(PACKAGE_ROOT, trimmed);
+    if (isInside(PACKAGE_ROOT, packageCandidate)) {
+        candidates.push(packageCandidate);
+    }
+    return candidates;
+}
+async function resolveCuratedSkillContent(paths, entry) {
+    for (const candidate of localSourcePathCandidates(paths, entry.source_path)) {
+        const content = await readTextIfExists(candidate);
+        if (content !== undefined && content.trim().length > 0) {
+            return content;
+        }
+    }
+    return buildCuratedSkillContent(entry);
+}
+async function materializeLocalSourceSkill(paths, entry, content) {
+    const sourcePath = entry.source_path?.trim().replace(/\\/g, '/');
+    if (!sourcePath || !sourcePath.startsWith('.sdd/skills/'))
+        return;
+    const projectRoot = path.resolve(paths.projectRoot);
+    const targetPath = path.resolve(projectRoot, sourcePath);
+    if (!isInside(projectRoot, targetPath))
+        return;
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, content, 'utf-8');
+}
+export class SkillsSyncService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, options) {
+        const { paths } = await getRuntime(projectRoot);
+        const catalog = await loadSkillCatalogState(paths);
+        const bundleFilter = new Set((options?.bundles || []).map((bundle) => bundle.trim()).filter(Boolean));
+        const selected = catalog.skills.filter((entry) => {
+            if (options?.all || bundleFilter.size === 0)
+                return true;
+            return entry.bundle_ids.some((bundle) => bundleFilter.has(bundle));
+        });
+        await fs.mkdir(paths.skillsCuratedDir, { recursive: true });
+        const contentBySkillId = new Map();
+        for (const entry of selected) {
+            const content = await resolveCuratedSkillContent(paths, entry);
+            contentBySkillId.set(entry.id, content);
+            await materializeLocalSourceSkill(paths, entry, content);
+            const tx = new SddWriteTransaction();
+            const localDir = path.join(paths.skillsCuratedDir, entry.id);
+            tx.writeFile(path.join(localDir, 'SKILL.md'), content);
+            await tx.commit(paths.projectRoot, paths.memoryRoot, 'skills-sync.service (local dir)');
+        }
+        if (selected.length === 0) {
+            return { synced: 0, local_synced: 0, tools: [] };
+        }
+        const targetTools = (options?.tools && options.tools.length > 0
+            ? AI_TOOLS.filter((tool) => options.tools?.includes(tool.value))
+            : AI_TOOLS).filter((tool) => !!tool.skillsDir);
+        const syncedTools = [];
+        for (const tool of targetTools) {
+            const skillsRoot = path.join(projectRoot, tool.skillsDir, 'skills');
+            const toolExists = await fs
+                .access(path.join(projectRoot, tool.skillsDir))
+                .then(() => true)
+                .catch(() => false);
+            if (!toolExists)
+                continue;
+            await fs.mkdir(skillsRoot, { recursive: true });
+            for (const entry of selected) {
+                const content = contentBySkillId.get(entry.id) || await resolveCuratedSkillContent(paths, entry);
+                const dir = path.join(skillsRoot, entry.id);
+                await fs.mkdir(dir, { recursive: true });
+                await fs.writeFile(path.join(dir, 'SKILL.md'), content, 'utf-8');
+            }
+            syncedTools.push(tool.value);
+        }
+        return { synced: selected.length, local_synced: selected.length, tools: syncedTools };
+    }
+}
+//# sourceMappingURL=skills-sync.service.js.map

package/dist/core/sdd/services/start.service.d.ts

@@ -0,0 +1,26 @@
+import { FlowMode, Scale } from "../types.js";
+import { SddStores } from "../store/sdd-stores.js";
+export declare class StartService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, refOrText: string, options?: {
+        scale?: Scale;
+        render?: boolean;
+        schema?: string;
+        force?: boolean;
+        flowMode?: FlowMode;
+        forceTransition?: boolean;
+    }): Promise<{
+        featureId: string;
+        changeName: string;
+        status: "ARCHIVED" | "READY" | "IN_PROGRESS" | "DONE" | "BLOCKED" | "SYNC_REQUIRED" | "VERIFY_FAILED";
+        start_guardrails: import("../domain/lifecycle-guardrails.js").FeatureStartGuardrails;
+        active_path: string;
+        generated_docs: string[];
+        recommended_bundles: string[];
+        handoff_seed_refs: string[];
+        flow_mode: "direto" | "padrao" | "rigoroso";
+        start_commit_sha: string;
+    }>;
+}
+//# sourceMappingURL=start.service.d.ts.map