sdd-cli 0.1.22 → 0.1.24

package/dist/providers/gemini.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiProvider = void 0;
+exports.geminiVersion = geminiVersion;
+exports.geminiExec = geminiExec;
+const child_process_1 = require("child_process");
+function resolveCommand(input) {
+    if (process.platform !== "win32") {
+        return input;
+    }
+    const looksLikePath = input.includes("\\") || input.includes("/");
+    const hasExt = /\.[A-Za-z0-9]+$/.test(input);
+    if (!looksLikePath && !hasExt) {
+        return `${input}.cmd`;
+    }
+    return input;
+}
+function geminiVersion() {
+    const command = resolveCommand(process.env.SDD_GEMINI_BIN?.trim() || "gemini");
+    const useShell = process.platform === "win32" && command.toLowerCase().endsWith(".cmd");
+    const result = (0, child_process_1.spawnSync)(command, ["--version"], {
+        encoding: "utf-8",
+        shell: useShell
+    });
+    if (result.status !== 0) {
+        return { ok: false, output: "", error: result.stderr || "gemini not available" };
+    }
+    return { ok: true, output: result.stdout.trim() };
+}
+function geminiExec(prompt) {
+    const command = resolveCommand(process.env.SDD_GEMINI_BIN?.trim() || "gemini");
+    const model = process.env.SDD_GEMINI_MODEL?.trim();
+    const useShell = process.platform === "win32" && command.toLowerCase().endsWith(".cmd");
+    const normalizedPrompt = prompt.replace(/\r?\n/g, "\\n");
+    const env = {
+        ...process.env,
+        NO_COLOR: "1"
+    };
+    const modelArgs = model ? ["-m", model] : [];
+    const runPrimary = (withModel) => useShell
+        ? (0, child_process_1.spawnSync)(`${command} ${withModel && model ? `-m "${model.replace(/"/g, "\"\"")}" ` : ""}--prompt "${normalizedPrompt.replace(/"/g, "\"\"")}" --output-format json`, {
+            encoding: "utf-8",
+            shell: true,
+            env
+        })
+        : (0, child_process_1.spawnSync)(command, [...(withModel ? modelArgs : []), "--prompt", normalizedPrompt, "--output-format", "json"], {
+            encoding: "utf-8",
+            shell: false,
+            env
+        });
+    const runFallback = (withModel) => useShell
+        ? (0, child_process_1.spawnSync)(`${command} ${withModel && model ? `-m "${model.replace(/"/g, "\"\"")}" ` : ""}--prompt "${normalizedPrompt.replace(/"/g, "\"\"")}"`, {
+            encoding: "utf-8",
+            shell: true,
+            env
+        })
+        : (0, child_process_1.spawnSync)(command, [...(withModel ? modelArgs : []), "--prompt", normalizedPrompt], {
+            encoding: "utf-8",
+            shell: false,
+            env
+        });
+    let result = runPrimary(true);
+    if (result.status !== 0 && model) {
+        result = runPrimary(false);
+    }
+    if (result.status !== 0) {
+        result = runFallback(true);
+    }
+    if (result.status !== 0 && model) {
+        result = runFallback(false);
+    }
+    if (result.status !== 0) {
+        return { ok: false, output: result.stdout || "", error: result.stderr || "gemini exec failed" };
+    }
+    return { ok: true, output: result.stdout.trim() };
+}
+exports.geminiProvider = {
+    id: "gemini",
+    label: "Gemini",
+    version: geminiVersion,
+    exec: geminiExec
+};

package/dist/providers/index.d.ts

@@ -0,0 +1,16 @@
+import { AIProvider, ProviderId, ProviderPreference } from "./types";
+export declare function defaultProviderPreference(): ProviderPreference;
+export declare function parseProviderPreference(input?: string): ProviderPreference | null;
+export declare function listProviders(): AIProvider[];
+export type ProviderResolution = {
+    ok: true;
+    provider: AIProvider;
+    selected: ProviderId;
+    requested: ProviderPreference;
+} | {
+    ok: false;
+    requested: string;
+    reason: "invalid" | "unavailable";
+    details: string;
+};
+export declare function resolveProvider(requested?: string): ProviderResolution;

package/dist/providers/index.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultProviderPreference = defaultProviderPreference;
+exports.parseProviderPreference = parseProviderPreference;
+exports.listProviders = listProviders;
+exports.resolveProvider = resolveProvider;
+const codex_1 = require("./codex");
+const gemini_1 = require("./gemini");
+const config_1 = require("../config");
+const PROVIDERS = {
+    gemini: gemini_1.geminiProvider,
+    codex: codex_1.codexProvider
+};
+const AUTO_ORDER = ["gemini", "codex"];
+function normalizePreference(input) {
+    const raw = (input ?? "").trim().toLowerCase();
+    if (!raw) {
+        return null;
+    }
+    if (raw === "auto" || raw === "gemini" || raw === "codex") {
+        return raw;
+    }
+    return null;
+}
+function defaultProviderPreference() {
+    const fromEnv = normalizePreference(process.env.SDD_AI_PROVIDER_DEFAULT);
+    if (fromEnv) {
+        return fromEnv;
+    }
+    const config = (0, config_1.ensureConfig)();
+    const fromConfig = normalizePreference(config.ai.preferred_cli);
+    return fromConfig ?? "gemini";
+}
+function parseProviderPreference(input) {
+    return normalizePreference(input);
+}
+function listProviders() {
+    return AUTO_ORDER.map((id) => PROVIDERS[id]);
+}
+function resolveProvider(requested) {
+    const normalized = normalizePreference(requested);
+    if (!normalized) {
+        return {
+            ok: false,
+            requested: requested ?? "",
+            reason: "invalid",
+            details: "Use one of: gemini, codex, auto."
+        };
+    }
+    if (normalized === "auto") {
+        const preferred = defaultProviderPreference();
+        if (preferred !== "auto") {
+            const provider = PROVIDERS[preferred];
+            const status = provider.version();
+            if (status.ok) {
+                return { ok: true, provider, selected: preferred, requested: normalized };
+            }
+            return {
+                ok: false,
+                requested: normalized,
+                reason: "unavailable",
+                details: `${provider.label} not available: ${status.error || "provider unavailable"}`
+            };
+        }
+        for (const id of AUTO_ORDER) {
+            const provider = PROVIDERS[id];
+            const status = provider.version();
+            if (status.ok) {
+                return { ok: true, provider, selected: id, requested: normalized };
+            }
+        }
+        return {
+            ok: false,
+            requested: normalized,
+            reason: "unavailable",
+            details: "No provider available. Install/configure gemini or codex."
+        };
+    }
+    const provider = PROVIDERS[normalized];
+    const status = provider.version();
+    if (!status.ok) {
+        return {
+            ok: false,
+            requested: normalized,
+            reason: "unavailable",
+            details: `${provider.label} not available: ${status.error || "provider unavailable"}`
+        };
+    }
+    return { ok: true, provider, selected: normalized, requested: normalized };
+}

package/dist/providers/types.d.ts

@@ -0,0 +1,13 @@
+export type ProviderId = "gemini" | "codex";
+export type ProviderPreference = ProviderId | "auto";
+export type ProviderResult = {
+    ok: boolean;
+    output: string;
+    error?: string;
+};
+export type AIProvider = {
+    id: ProviderId;
+    label: string;
+    version: () => ProviderResult;
+    exec: (prompt: string) => ProviderResult;
+};

package/dist/providers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/router/intent.js

@@ -3,7 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FLOW_PROMPT_PACKS = void 0;
 exports.classifyIntent = classifyIntent;
 const SIGNALS = [
-    { intent: "bug_fix", flow: "BUG_FIX", domain: "bug_fix", keywords: ["bug", "issue", "error", "crash", "stack"] },
+    {
+        intent: "bug_fix",
+        flow: "BUG_FIX",
+        domain: "bug_fix",
+        keywords: ["bug", "issue", "error", "crash", "stack trace", "stacktrace"]
+    },
     { intent: "pr_review", flow: "PR_REVIEW", domain: "pr_review", keywords: ["pr", "pull request", "review"] },
     {
         intent: "learning",
@@ -31,7 +36,25 @@ const SIGNALS = [
         intent: "software",
         flow: "SOFTWARE_FEATURE",
         domain: "software",
-        keywords: ["feature", "api", "backend", "frontend", "implement", "developer", "refactor", "code"]
+        keywords: [
+            "feature",
+            "api",
+            "backend",
+            "frontend",
+            "implement",
+            "developer",
+            "refactor",
+            "code",
+            "crear",
+            "crea",
+            "aplicacion",
+            "aplicación",
+            "app",
+            "web",
+            "desktop",
+            "movil",
+            "móvil"
+        ]
     }
 ];
 exports.FLOW_PROMPT_PACKS = {
@@ -48,14 +71,21 @@ exports.FLOW_PROMPT_PACKS = {
 };
 function classifyIntent(input) {
     const normalized = input.toLowerCase();
+    const containsKeyword = (keyword) => {
+        const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        if (escaped.length <= 3 && !escaped.includes(" ")) {
+            return new RegExp(`\\b${escaped}\\b`, "i").test(normalized);
+        }
+        return normalized.includes(keyword);
+    };
     for (const rule of SIGNALS) {
-        if (rule.keywords.some((keyword) => normalized.includes(keyword))) {
+        if (rule.keywords.some((keyword) => containsKeyword(keyword))) {
             return {
                 intent: rule.intent,
                 confidence: 0.7,
                 flow: rule.flow,
                 domain: rule.domain,
-                signals: rule.keywords.filter((keyword) => normalized.includes(keyword))
+                signals: rule.keywords.filter((keyword) => containsKeyword(keyword))
             };
         }
     }

package/dist/workspace/index.js

@@ -17,8 +17,8 @@ exports.createProject = createProject;
 exports.updateProjectStatus = updateProjectStatus;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
 const flags_1 = require("../context/flags");
+const config_1 = require("../config");
 const WORKSPACE_LOCK_RETRY_MS = 50;
 const WORKSPACE_LOCK_WAIT_MS = 5000;
 const WORKSPACE_LOCK_STALE_MS = 30000;
@@ -119,11 +119,11 @@ function getWorkspaceInfoForScope(scope) {
 }
 function getWorkspaceBaseRoot() {
     const flags = (0, flags_1.getFlags)();
-    return flags.output
-        ? path_1.default.resolve(flags.output)
-        : process.env.APPDATA
-            ? path_1.default.join(process.env.APPDATA, "sdd-cli", "workspaces")
-            : path_1.default.join(os_1.default.homedir(), ".config", "sdd-cli", "workspaces");
+    if (flags.output) {
+        return path_1.default.resolve(flags.output);
+    }
+    const config = (0, config_1.ensureConfig)();
+    return path_1.default.resolve(config.workspace.default_root);
 }
 function listScopes(baseRoot) {
     const root = baseRoot ? path_1.default.resolve(baseRoot) : getWorkspaceBaseRoot();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sdd-cli",
-  "version": "0.1.22",
-  "description": "Use sdd-cli to turn ideas, GitHub/Jira work items, and PR feedback into actionable requirements, specs, plans, and done-ready delivery records with guided workflows.",
+  "version": "0.1.24",
+  "description": "AI-orchestrated specification-driven delivery CLI that plans, validates, and ships production-ready software projects.",
   "keywords": [
     "cli",
     "specification-driven-development",
@@ -25,10 +25,11 @@
   "bugs": {
     "url": "https://github.com/jdsalasca/sdd-tool/issues"
   },
-  "bin": {
-    "sdd-cli": "dist/cli.js",
-    "sdd": "dist/cli.js"
-  },
+  "bin": {
+    "sdd-cli": "dist/cli.js",
+    "sdd": "dist/cli.js",
+    "sdd-tool": "dist/cli.js"
+  },
   "main": "dist/cli.js",
   "types": "dist/cli.d.ts",
   "files": [