specrails-desktop 2.0.0

package/server/dist/build-dirs.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILD_DIRS = void 0;
+exports.isInBuildDir = isInBuildDir;
+/**
+ * Shared deny-set of directory segment names that hold build output, vendored
+ * dependencies, or VCS metadata. These trees can contain tens of thousands of
+ * constantly-rewritten files (e.g. a Rust `target/` or a Tauri `src-tauri/target`
+ * with the assembled app bundle) and must never be recursively watched or walked.
+ *
+ * Recursively watching such a tree was the confirmed root cause of a file-descriptor
+ * leak (~10k fds) that, under fd pressure, made node-pty's forkpty fail to give the
+ * child shell a controlling tty — the shell then read EOF and exited instantly,
+ * producing dead/hung terminals. See server/file-summary-manager.ts (the watcher)
+ * and server/code-explorer-router.ts (the on-demand tree walk).
+ *
+ * Dot-directories (`.git`, `.next`, `.turbo`, `.venv`, …) are handled separately
+ * by a `startsWith('.')` segment check so we don't have to enumerate every one.
+ */
+exports.BUILD_DIRS = new Set([
+    'node_modules',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    'target', // rust / java / sbt — also covers src-tauri/target
+    'vendor', // go / php
+]);
+/**
+ * True when any segment of the (relative) path is a build/dep dir or a
+ * dot-directory. Pass a path RELATIVE to the project root so a dot-segment in
+ * the absolute prefix (e.g. a user's home dir) cannot cause a false positive.
+ */
+function isInBuildDir(relPath) {
+    for (const seg of relPath.split(/[\\/]/)) {
+        if (!seg || seg === '.' || seg === '..')
+            continue;
+        if (seg.startsWith('.'))
+            return true;
+        if (exports.BUILD_DIRS.has(seg))
+            return true;
+    }
+    return false;
+}

package/server/dist/changes-reader.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readChanges = readChanges;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** Parse simple flat key: value YAML (no nesting needed for .openspec.yaml) */
+function readOpenSpecYaml(changeDir) {
+    const yamlPath = path_1.default.join(changeDir, '.openspec.yaml');
+    if (!fs_1.default.existsSync(yamlPath))
+        return {};
+    try {
+        const text = fs_1.default.readFileSync(yamlPath, 'utf-8');
+        const meta = {};
+        for (const line of text.split('\n')) {
+            const m = line.match(/^(\w+):\s*(.+)$/);
+            if (!m)
+                continue;
+            if (m[1] === 'created')
+                meta.created = m[2].trim();
+            if (m[1] === 'archived')
+                meta.archived = m[2].trim();
+        }
+        return meta;
+    }
+    catch {
+        return {};
+    }
+}
+function hasFile(dir, filename) {
+    return fs_1.default.existsSync(path_1.default.join(dir, filename));
+}
+function mtimeIso(dir) {
+    try {
+        return fs_1.default.statSync(dir).mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+function classifyPhase(artifacts, isArchived, activeCommandNames, changeId) {
+    if (isArchived)
+        return 'shipped';
+    if (artifacts.tasks && activeCommandNames.has(changeId))
+        return 'building';
+    if (artifacts.tasks)
+        return 'ready';
+    if (artifacts.design)
+        return 'designing';
+    return 'exploring';
+}
+function slugToName(id) {
+    // Strip leading ticket prefix like "spea-123-" and convert to title case
+    return id
+        .replace(/^[a-z]+-\d+-/, '')
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function readChangesFromDir(changesDir, isArchived, activeCommandNames) {
+    if (!fs_1.default.existsSync(changesDir))
+        return [];
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(changesDir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => {
+        try {
+            return fs_1.default.statSync(path_1.default.join(changesDir, entry)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .map((entry) => {
+        const changeDir = path_1.default.join(changesDir, entry);
+        const meta = readOpenSpecYaml(changeDir);
+        const artifacts = {
+            proposal: hasFile(changeDir, 'proposal.md'),
+            design: hasFile(changeDir, 'design.md'),
+            tasks: hasFile(changeDir, 'tasks.md'),
+        };
+        const archivedAt = isArchived
+            ? meta.archived ?? mtimeIso(changeDir)
+            : null;
+        const phase = classifyPhase(artifacts, isArchived, activeCommandNames, entry);
+        return {
+            id: entry,
+            name: slugToName(entry),
+            phase,
+            artifacts,
+            createdAt: meta.created ?? null,
+            isArchived,
+            archivedAt,
+        };
+    });
+}
+/**
+ * Read all OpenSpec changes for a given project path.
+ * @param projectPath - absolute path to the project root
+ * @param activeJobCommands - list of currently active job commands (to detect "building" phase)
+ */
+function readChanges(projectPath, activeJobCommands = []) {
+    const changesRoot = path_1.default.join(projectPath, 'openspec', 'changes');
+    const archiveDir = path_1.default.join(changesRoot, 'archive');
+    // Build a set of change IDs that appear in active job commands
+    const activeCommandNames = new Set(activeJobCommands.flatMap((cmd) => {
+        // Match change IDs by looking for opsx:* commands referencing change names
+        const match = cmd.match(/opsx:[a-z-]+\s+(\S+)/);
+        return match ? [match[1]] : [];
+    }));
+    const active = readChangesFromDir(changesRoot, false, activeCommandNames).filter((c) => c.id !== 'archive');
+    const archived = readChangesFromDir(archiveDir, true, activeCommandNames);
+    return [...active, ...archived];
+}