specrails-desktop 2.0.0

package/server/dist/explore-cwd-manager.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderExploreInstructions = renderExploreInstructions;
+exports.renderExploreClaudeMd = renderExploreClaudeMd;
+exports.exploreCwdPathFor = exploreCwdPathFor;
+exports.ensureExploreCwd = ensureExploreCwd;
+exports.removeExploreCwd = removeExploreCwd;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const providers_1 = require("./providers");
+/**
+ * ExploreCwdManager owns the per-project app-managed cwd used to spawn the
+ * provider CLI for Explore Spec turns. See openspec/changes/accelerate-spec-
+ * chat-first-token/design.md decisions D1–D3 + D9, and openspec/changes/
+ * add-multi-provider-support/specs/explore-spec/spec.md for the multi-
+ * provider behaviour (instructions file is adapter-driven: CLAUDE.md for
+ * claude, AGENTS.md for codex).
+ *
+ * Layout under `~/.specrails/projects/<slug>/explore-cwd/`:
+ *   ├── <adapter.instructionsFilename>  — embedded mini-prompt, app-owned
+ *   ├── project                          — symlink/junction → <project.path>
+ *   └── project-path.txt                 — fallback when symlink creation fails
+ */
+/** Embedded Explore instructions template. Interpolates {{projectName}}. */
+const EXPLORE_INSTRUCTIONS_TEMPLATE = `# Explore Spec assistant for "{{projectName}}"
+
+You are running inside the **Explore Spec** experience of Specrails. The
+user has opened a thinking-partner conversation to shape a single backlog
+ticket. The app commits the final ticket — you never write to disk and never
+invoke ticket-creation slash commands.
+
+## Where you are
+
+- The current working directory is an app-managed scratch directory; it does
+  NOT contain the user's source code.
+- The user's repo is mounted at \`./project\`. Read it ONLY when the spec
+  actually requires evidence (e.g. the user names a concrete file or feature).
+  Do not pre-emptively enumerate the repo or open dozens of files.
+- If \`./project\` does not resolve (rare; e.g. symlink creation failed on
+  Windows), a sibling file \`project-path.txt\` contains the absolute project
+  path. Use that path with absolute reads in that case.
+
+## What you must do
+
+- Act as an interactive thinking partner for this ticket draft: investigate
+  just enough, ask only the questions you need, surface trade-offs, propose a
+  concrete shape.
+- Maintain the structured live draft via fenced \`spec-draft\` JSON blocks at
+  the end of every turn that updates draft state. The app parses these blocks
+  and updates the user's draft pane; the block itself is stripped from the
+  visible chat output.
+- Set \`ready: true\` in the draft block only when the draft has a title, a
+  description, at least one acceptance criterion, and no outstanding
+  clarifying question for the user.
+
+## What you must NOT do
+
+- Do NOT create or modify any files in this cwd or in \`./project\`.
+- Do NOT call \`/specrails:propose-spec\`, \`/specrails:implement\`, or any
+  slash command that produces side effects in the project. The app owns the
+  commit via \`POST /tickets/from-draft\` when the user clicks Create Spec.
+- Do NOT modify, rewrite, or reference the user's own \`./project/CLAUDE.md\`
+  in your output. It exists for other purposes.
+
+## Style
+
+- Be brief. A short observation plus a focused question beats a paragraph.
+- Spec content (\`title\`, \`description\`, \`labels\`, \`acceptanceCriteria\`)
+  is always written in English. Conversational prose mirrors the user's
+  language.
+
+The user's first message follows. Begin the conversation.
+`;
+/**
+ * Render the embedded template for a given project name.
+ * Exported for testing.
+ */
+function renderExploreInstructions(projectName) {
+    return EXPLORE_INSTRUCTIONS_TEMPLATE.replace(/\{\{projectName\}\}/g, projectName);
+}
+/** @deprecated Use `renderExploreInstructions` — kept as a thin wrapper so
+ *  any external callsite continues to compile. */
+function renderExploreClaudeMd(projectName) {
+    return renderExploreInstructions(projectName);
+}
+/**
+ * Compute the explore-cwd path for a project without touching the filesystem.
+ * Used by the legacy-cwd env-var short-circuit and by tests.
+ */
+function exploreCwdPathFor(slug, baseDir) {
+    const base = baseDir ?? path_1.default.join(os_1.default.homedir(), '.specrails', 'projects');
+    return path_1.default.join(base, slug, 'explore-cwd');
+}
+/**
+ * Create or refresh the explore-cwd for a project. Idempotent and cheap when
+ * already up-to-date. Returns the absolute path to the cwd.
+ *
+ * When SPECRAILS_EXPLORE_LEGACY_CWD=1 is set, returns `projectPath` directly
+ * and performs no filesystem IO — used as the rollback escape hatch.
+ *
+ * Pass `baseDir` for tests to redirect away from the user's home directory.
+ */
+function ensureExploreCwd(input, baseDir) {
+    if (process.env.SPECRAILS_EXPLORE_LEGACY_CWD === '1') {
+        return input.projectPath;
+    }
+    const cwd = exploreCwdPathFor(input.slug, baseDir);
+    fs_1.default.mkdirSync(cwd, { recursive: true });
+    const adapter = (0, providers_1.getAdapter)(input.provider ?? 'claude');
+    const instructionsPath = path_1.default.join(cwd, adapter.instructionsFilename);
+    const desiredInstructions = renderExploreInstructions(input.projectName);
+    let currentInstructions = null;
+    try {
+        currentInstructions = fs_1.default.readFileSync(instructionsPath, 'utf-8');
+    }
+    catch {
+        /* file may not exist yet */
+    }
+    if (currentInstructions !== desiredInstructions) {
+        fs_1.default.writeFileSync(instructionsPath, desiredInstructions, 'utf-8');
+    }
+    // If the project switched providers since the last materialise (defensive
+    // — provider is immutable post-creation but the lifecycle code MUST handle
+    // the edge per spec), remove any stale instructions file authored by a
+    // different provider so the explore-cwd doesn't carry both.
+    const STALE_INSTRUCTION_FILES = ['CLAUDE.md', 'AGENTS.md'];
+    for (const stale of STALE_INSTRUCTION_FILES) {
+        if (stale === adapter.instructionsFilename)
+            continue;
+        const stalePath = path_1.default.join(cwd, stale);
+        if (fs_1.default.existsSync(stalePath)) {
+            try {
+                fs_1.default.unlinkSync(stalePath);
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    ensureProjectLink(cwd, input.projectPath);
+    return cwd;
+}
+/**
+ * Recursively remove the explore-cwd directory for a project. The `project`
+ * symlink/junction is unlinked explicitly (never followed) so the user's
+ * repo is never touched.
+ */
+function removeExploreCwd(slug, baseDir) {
+    const cwd = exploreCwdPathFor(slug, baseDir);
+    if (!fs_1.default.existsSync(cwd))
+        return;
+    const linkPath = path_1.default.join(cwd, 'project');
+    try {
+        const st = fs_1.default.lstatSync(linkPath);
+        if (st.isSymbolicLink() || (process.platform === 'win32' && st.isDirectory())) {
+            // unlink works on POSIX symlinks; rmdir on Windows junctions
+            try {
+                fs_1.default.unlinkSync(linkPath);
+            }
+            catch {
+                try {
+                    fs_1.default.rmdirSync(linkPath);
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
+    catch {
+        /* link may not exist */
+    }
+    fs_1.default.rmSync(cwd, { recursive: true, force: true });
+}
+/**
+ * Ensure `<cwd>/project` resolves to `<projectPath>` (symlink on POSIX,
+ * junction on Windows). Recreated when the existing target differs. On both
+ * symlink and junction failure, writes a `project-path.txt` fallback that
+ * the embedded CLAUDE.md tells the model to read.
+ */
+function ensureProjectLink(cwd, projectPath) {
+    const linkPath = path_1.default.join(cwd, 'project');
+    const fallbackPath = path_1.default.join(cwd, 'project-path.txt');
+    let needsCreate = true;
+    try {
+        const st = fs_1.default.lstatSync(linkPath);
+        if (st.isSymbolicLink()) {
+            const current = fs_1.default.readlinkSync(linkPath);
+            if (path_1.default.resolve(cwd, current) === path_1.default.resolve(projectPath)) {
+                needsCreate = false;
+            }
+            else {
+                fs_1.default.unlinkSync(linkPath);
+            }
+        }
+        else {
+            // existing non-symlink (e.g. Windows junction or stale dir) — replace
+            try {
+                fs_1.default.unlinkSync(linkPath);
+            }
+            catch {
+                try {
+                    fs_1.default.rmdirSync(linkPath);
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
+    catch {
+        /* link does not exist — fall through to create */
+    }
+    if (needsCreate) {
+        let created = false;
+        if (process.platform === 'win32') {
+            try {
+                fs_1.default.symlinkSync(projectPath, linkPath, 'junction');
+                created = true;
+            }
+            catch { /* fall through to plain symlink */ }
+        }
+        if (!created) {
+            try {
+                fs_1.default.symlinkSync(projectPath, linkPath);
+                created = true;
+            }
+            catch { /* fall through to text fallback */ }
+        }
+        if (!created) {
+            // Final fallback: write the absolute path so the model can use it.
+            fs_1.default.writeFileSync(fallbackPath, projectPath, 'utf-8');
+            return;
+        }
+    }
+    // If we successfully created/verified the symlink, clean up any stale
+    // fallback file from a prior failed attempt.
+    if (fs_1.default.existsSync(fallbackPath)) {
+        try {
+            fs_1.default.unlinkSync(fallbackPath);
+        }
+        catch { /* ignore */ }
+    }
+}

package/server/dist/explore-draft-title.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Auto-title generation for Explore drafts.
+ *
+ * Strategy: deterministic single-line summary derived from the first
+ * user-submitted message in the conversation. Future enhancement: replace
+ * `generateAutoTitle` with an LLM-backed implementation that calls Claude
+ * with a short prompt and falls back to the deterministic path on failure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAutoTitle = generateAutoTitle;
+const MAX_TITLE_LEN = 80;
+const FALLBACK_TITLE = 'Untitled draft';
+/**
+ * Produce a non-empty, single-line, human-meaningful title from a
+ * conversation transcript. Always returns a non-empty string.
+ */
+function generateAutoTitle(messages) {
+    const firstUser = messages.find((m) => m.role === 'user' && m.content.trim().length > 0);
+    if (!firstUser)
+        return FALLBACK_TITLE;
+    return summarizeToSingleLine(firstUser.content);
+}
+function summarizeToSingleLine(text) {
+    // Strip code fences and inline backticks — drafts are about ideas, not code
+    const stripped = text
+        .replace(/```[\s\S]*?```/g, ' ')
+        .replace(/`[^`]*`/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!stripped)
+        return FALLBACK_TITLE;
+    // Prefer the first sentence if it's short enough
+    const sentenceMatch = stripped.match(/^.{1,80}?[.!?](\s|$)/);
+    if (sentenceMatch) {
+        const sentence = sentenceMatch[0].trim().replace(/[.!?]+$/, '');
+        if (sentence.length > 0)
+            return sentence;
+    }
+    if (stripped.length <= MAX_TITLE_LEN)
+        return stripped;
+    // Word-aware truncation
+    const head = stripped.slice(0, MAX_TITLE_LEN);
+    const lastSpace = head.lastIndexOf(' ');
+    const truncated = lastSpace > 20 ? head.slice(0, lastSpace) : head;
+    return truncated.trim() + '…';
+}