sdd-cli 0.1.19 → 0.1.21

package/dist/telemetry/local-metrics.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordCommandMetric = recordCommandMetric;
+exports.recordActivationMetric = recordActivationMetric;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const flags_1 = require("../context/flags");
+const index_1 = require("../workspace/index");
+function isEnabled() {
+    const flags = (0, flags_1.getFlags)();
+    return Boolean(flags.metricsLocal) || process.env.SDD_METRICS_LOCAL === "1";
+}
+function metricsPath() {
+    const workspace = (0, index_1.getWorkspaceInfo)();
+    (0, index_1.ensureWorkspace)(workspace);
+    const dir = path_1.default.join(workspace.root, "metrics");
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    return path_1.default.join(dir, "local-metrics.json");
+}
+function loadSnapshot(filePath) {
+    if (!fs_1.default.existsSync(filePath)) {
+        const now = new Date().toISOString();
+        return {
+            firstSeenAt: now,
+            lastSeenAt: now,
+            commandCounts: {},
+            activation: { started: 0, completed: 0 },
+            events: []
+        };
+    }
+    try {
+        const raw = fs_1.default.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            firstSeenAt: parsed.firstSeenAt || new Date().toISOString(),
+            lastSeenAt: parsed.lastSeenAt || new Date().toISOString(),
+            commandCounts: parsed.commandCounts || {},
+            activation: parsed.activation || { started: 0, completed: 0 },
+            events: Array.isArray(parsed.events) ? parsed.events : []
+        };
+    }
+    catch {
+        const now = new Date().toISOString();
+        return {
+            firstSeenAt: now,
+            lastSeenAt: now,
+            commandCounts: {},
+            activation: { started: 0, completed: 0 },
+            events: []
+        };
+    }
+}
+function recordCommandMetric(command) {
+    if (!isEnabled()) {
+        return;
+    }
+    const file = metricsPath();
+    const snapshot = loadSnapshot(file);
+    const now = new Date().toISOString();
+    snapshot.lastSeenAt = now;
+    snapshot.commandCounts[command] = (snapshot.commandCounts[command] || 0) + 1;
+    snapshot.events.push({ at: now, type: "command", data: { command } });
+    if (snapshot.events.length > 200) {
+        snapshot.events = snapshot.events.slice(snapshot.events.length - 200);
+    }
+    fs_1.default.writeFileSync(file, JSON.stringify(snapshot, null, 2), "utf-8");
+}
+function recordActivationMetric(type, data) {
+    if (!isEnabled()) {
+        return;
+    }
+    const file = metricsPath();
+    const snapshot = loadSnapshot(file);
+    const now = new Date().toISOString();
+    snapshot.lastSeenAt = now;
+    snapshot.activation[type] = (snapshot.activation[type] || 0) + 1;
+    snapshot.events.push({ at: now, type: `activation.${type}`, data });
+    if (snapshot.events.length > 200) {
+        snapshot.events = snapshot.events.slice(snapshot.events.length - 200);
+    }
+    fs_1.default.writeFileSync(file, JSON.stringify(snapshot, null, 2), "utf-8");
+}

package/dist/workspace/index.d.ts

@@ -17,7 +17,11 @@ export type ProjectInfo = {
     name: string;
     root: string;
 };
+export declare function normalizeScopeName(name: string): string;
 export declare function getWorkspaceInfo(): WorkspaceInfo;
+export declare function getWorkspaceInfoForScope(scope?: string): WorkspaceInfo;
+export declare function getWorkspaceBaseRoot(): string;
+export declare function listScopes(baseRoot?: string): string[];
 export declare function ensureWorkspace(workspace: WorkspaceInfo): void;
 export declare function normalizeProjectName(name: string): string;
 export declare function getProjectInfo(workspace: WorkspaceInfo, name: string): ProjectInfo;

package/dist/workspace/index.js

@@ -3,7 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeScopeName = normalizeScopeName;
 exports.getWorkspaceInfo = getWorkspaceInfo;
+exports.getWorkspaceInfoForScope = getWorkspaceInfoForScope;
+exports.getWorkspaceBaseRoot = getWorkspaceBaseRoot;
+exports.listScopes = listScopes;
 exports.ensureWorkspace = ensureWorkspace;
 exports.normalizeProjectName = normalizeProjectName;
 exports.getProjectInfo = getProjectInfo;
@@ -15,6 +19,22 @@ 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 WORKSPACE_LOCK_RETRY_MS = 50;
+const WORKSPACE_LOCK_WAIT_MS = 5000;
+const WORKSPACE_LOCK_STALE_MS = 30000;
+function normalizeScopeName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        throw new Error("Scope name is required.");
+    }
+    if (trimmed.includes("..") || trimmed.includes("/") || trimmed.includes("\\")) {
+        throw new Error("Scope name cannot contain path separators.");
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9 _-]*$/.test(trimmed)) {
+        throw new Error("Scope name must use letters, numbers, spaces, '-' or '_' only.");
+    }
+    return trimmed;
+}
 function readJsonFile(filePath) {
     try {
         const raw = fs_1.default.readFileSync(filePath, "utf-8");
@@ -31,24 +51,102 @@ function readWorkspaceIndex(workspace) {
     }
     return { projects: parsed.projects };
 }
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function isStaleLock(lockPath) {
+    try {
+        const stats = fs_1.default.statSync(lockPath);
+        return Date.now() - stats.mtimeMs > WORKSPACE_LOCK_STALE_MS;
+    }
+    catch {
+        return false;
+    }
+}
+function withWorkspaceIndexLock(workspace, fn) {
+    const lockPath = `${workspace.indexPath}.lock`;
+    const start = Date.now();
+    while (true) {
+        try {
+            const fd = fs_1.default.openSync(lockPath, "wx");
+            try {
+                const payload = JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() });
+                fs_1.default.writeFileSync(fd, payload, "utf-8");
+            }
+            finally {
+                fs_1.default.closeSync(fd);
+            }
+            break;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "EEXIST") {
+                throw err;
+            }
+            if (isStaleLock(lockPath)) {
+                fs_1.default.rmSync(lockPath, { force: true });
+                continue;
+            }
+            if (Date.now() - start > WORKSPACE_LOCK_WAIT_MS) {
+                throw new Error("Workspace index is locked by another process. Retry shortly.");
+            }
+            sleepSync(WORKSPACE_LOCK_RETRY_MS);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(lockPath, { force: true });
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+}
 function getWorkspaceInfo() {
     const flags = (0, flags_1.getFlags)();
-    const root = flags.output
+    const scope = flags.scope && flags.scope.trim().length > 0 ? normalizeScopeName(flags.scope) : undefined;
+    return getWorkspaceInfoForScope(scope);
+}
+function getWorkspaceInfoForScope(scope) {
+    const baseRoot = getWorkspaceBaseRoot();
+    const normalizedScope = scope && scope.trim().length > 0 ? normalizeScopeName(scope) : "";
+    const root = normalizedScope ? path_1.default.join(baseRoot, normalizedScope) : baseRoot;
+    const indexPath = path_1.default.join(root, "workspaces.json");
+    return { root, indexPath };
+}
+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");
-    const indexPath = path_1.default.join(root, "workspaces.json");
-    return { root, indexPath };
+}
+function listScopes(baseRoot) {
+    const root = baseRoot ? path_1.default.resolve(baseRoot) : getWorkspaceBaseRoot();
+    if (!fs_1.default.existsSync(root)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((name) => fs_1.default.existsSync(path_1.default.join(root, name, "workspaces.json")))
+        .sort();
 }
 function ensureWorkspace(workspace) {
     if (!fs_1.default.existsSync(workspace.root)) {
         fs_1.default.mkdirSync(workspace.root, { recursive: true });
     }
-    if (!fs_1.default.existsSync(workspace.indexPath)) {
-        const emptyIndex = { projects: [] };
-        fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(emptyIndex, null, 2), "utf-8");
-    }
+    withWorkspaceIndexLock(workspace, () => {
+        if (!fs_1.default.existsSync(workspace.indexPath)) {
+            const emptyIndex = { projects: [] };
+            fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(emptyIndex, null, 2), "utf-8");
+        }
+    });
 }
 function normalizeProjectName(name) {
     const trimmed = name.trim();
@@ -121,16 +219,18 @@ function ensureProject(workspace, name, domain) {
         };
         fs_1.default.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
     }
-    const index = readWorkspaceIndex(workspace);
-    index.projects = index.projects ?? [];
-    const existing = index.projects.find((entry) => entry.name === project.name);
-    if (existing) {
-        existing.status = metadata.status;
-    }
-    else {
-        index.projects.push({ name: metadata.name, status: metadata.status });
-    }
-    fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    withWorkspaceIndexLock(workspace, () => {
+        const index = readWorkspaceIndex(workspace);
+        index.projects = index.projects ?? [];
+        const existing = index.projects.find((entry) => entry.name === project.name);
+        if (existing) {
+            existing.status = metadata.status;
+        }
+        else {
+            index.projects.push({ name: metadata.name, status: metadata.status });
+        }
+        fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    });
     return metadata;
 }
 function createProject(workspace, name, domain) {
@@ -139,16 +239,18 @@ function createProject(workspace, name, domain) {
 function updateProjectStatus(workspace, name, status) {
     ensureWorkspace(workspace);
     const project = getProjectInfo(workspace, name);
-    const index = readWorkspaceIndex(workspace);
-    index.projects = index.projects ?? [];
-    const existing = index.projects.find((entry) => entry.name === project.name);
-    if (existing) {
-        existing.status = status;
-    }
-    else {
-        index.projects.push({ name: project.name, status });
-    }
-    fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    withWorkspaceIndexLock(workspace, () => {
+        const index = readWorkspaceIndex(workspace);
+        index.projects = index.projects ?? [];
+        const existing = index.projects.find((entry) => entry.name === project.name);
+        if (existing) {
+            existing.status = status;
+        }
+        else {
+            index.projects.push({ name: project.name, status });
+        }
+        fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    });
     const projectRoot = project.root;
     const metadataPath = path_1.default.join(projectRoot, "metadata.json");
     const metadata = fs_1.default.existsSync(metadataPath) ? readJsonFile(metadataPath) : null;

package/package.json

@@ -1,7 +1,22 @@
 {
   "name": "sdd-cli",
-  "version": "0.1.19",
-  "description": "SDD-first, AI-native CLI for end-to-end delivery.",
+  "version": "0.1.21",
+  "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.",
+  "keywords": [
+    "cli",
+    "specification-driven-development",
+    "software-design-document",
+    "requirements",
+    "architecture",
+    "technical-spec",
+    "workflow",
+    "autopilot",
+    "project-management"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
   "homepage": "https://github.com/jdsalasca/sdd-tool#readme",
   "repository": {
     "type": "git",
@@ -28,6 +43,13 @@
     "start": "node dist/cli.js",
     "dev": "ts-node src/cli.ts",
     "check:docs": "node scripts/check-docs-flags.js",
+    "check:error-codes": "node scripts/check-error-codes.js",
+    "release:notes": "node scripts/generate-release-notes.js",
+    "release:changelog": "node scripts/update-changelog.js",
+    "release:metrics": "node scripts/post-release-metrics.js",
+    "verify:publish": "node scripts/verify-publish-ready.js",
+    "verify:release-tag": "node scripts/verify-release-version.js",
+    "metrics:summary": "node scripts/metrics-summary.js",
     "smoke:autopilot": "node scripts/autopilot-smoke.js",
     "preinstall": "node scripts/preinstall.js",
     "pretest": "npm run build",