devglide 0.1.1

package/src/apps/log/src/services/file-tailer.ts

@@ -0,0 +1,228 @@
+import { watch, type FSWatcher } from "chokidar";
+import fsp from "fs/promises";
+import path from "path";
+import crypto from "crypto";
+import { LogWriter } from "./log-writer.js";
+import { parseLine } from "./line-parser.js";
+import { recordSession, getTargetPaths } from "../routes/log.js";
+import {
+  INCLUDE_PATTERNS,
+  IGNORED_GLOBS,
+  MAX_DEPTH,
+  MAX_WATCHED_FILES,
+  MAX_FILE_SIZE,
+} from "./file-patterns.js";
+
+function fileSessionId(filePath: string): string {
+  const hash = crypto.createHash("md5").update(filePath).digest("hex").slice(0, 12);
+  return `file-${hash}`;
+}
+
+function filetailTargetPath(projectPath: string, filePath: string): string {
+  const basename = path.basename(filePath, ".log");
+  return path.join(projectPath, `${basename}.filetail.log`);
+}
+
+export class FileTailer {
+  private watcher: FSWatcher | null = null;
+  private offsets = new Map<string, number>();
+  private partials = new Map<string, string>();
+  private changeQueues = new Map<string, Promise<void>>();
+  private logWriter = new LogWriter();
+  private projectPath: string | null = null;
+  private watchedCount = 0;
+
+  async start(projectPath: string): Promise<void> {
+    this.stop();
+    this.projectPath = projectPath;
+
+    const globs = INCLUDE_PATTERNS.map((p) => path.join(projectPath, p));
+
+    this.watcher = watch(globs, {
+      ignored: IGNORED_GLOBS,
+      depth: MAX_DEPTH,
+      persistent: true,
+      ignoreInitial: false,
+      awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+    });
+
+    this.watcher.on("add", (filePath: string) => this.onAdd(filePath));
+    this.watcher.on("change", (filePath: string) => this.onChange(filePath));
+    this.watcher.on("unlink", (filePath: string) => this.onUnlink(filePath));
+    this.watcher.on("error", (err: unknown) => {
+      console.error("[file-tailer] watcher error:", (err as Error).message);
+    });
+
+    console.log(`[file-tailer] Watching for log files in ${projectPath}`);
+  }
+
+  stop(): void {
+    if (this.watcher) {
+      this.watcher.close().catch(() => {});
+      this.watcher = null;
+    }
+    this.offsets.clear();
+    this.partials.clear();
+    this.changeQueues.clear();
+    this.watchedCount = 0;
+    if (this.projectPath) {
+      console.log(`[file-tailer] Stopped watching ${this.projectPath}`);
+    }
+    this.projectPath = null;
+  }
+
+  private async onAdd(filePath: string): Promise<void> {
+    if (this.watchedCount >= MAX_WATCHED_FILES) return;
+
+    // Skip files already managed by DevGlide sniffers (browser/server)
+    const absPath = path.resolve(filePath);
+    const managedPaths = getTargetPaths();
+    if (managedPaths.some((p) => path.resolve(p) === absPath)) {
+      console.log(`[file-tailer] Skipping managed file: ${filePath}`);
+      return;
+    }
+
+    try {
+      const stat = await fsp.stat(filePath);
+      if (stat.size > MAX_FILE_SIZE) {
+        console.log(`[file-tailer] Skipping large file: ${filePath} (${(stat.size / 1024 / 1024).toFixed(1)}MB)`);
+        return;
+      }
+
+      // Peek at first line — skip if it looks like a DevGlide JSONL file
+      if (stat.size > 0 && (await this.isDevGlideJsonl(filePath))) {
+        console.log(`[file-tailer] Skipping DevGlide JSONL file: ${filePath}`);
+        return;
+      }
+
+      // Start from end of file — only tail new content
+      this.offsets.set(filePath, stat.size);
+      this.partials.set(filePath, "");
+      this.watchedCount++;
+
+      const sessionId = fileSessionId(filePath);
+      const targetPath = filetailTargetPath(this.projectPath!, filePath);
+      const basename = path.basename(filePath);
+
+      const entry = {
+        type: "FILE_SESSION_START",
+        session: sessionId,
+        ts: new Date().toISOString(),
+        message: `Tailing ${basename}`,
+        targetPath,
+        persistent: true,
+        source: filePath,
+      };
+
+      recordSession(entry);
+      await this.logWriter.append(targetPath, entry);
+
+      console.log(`[file-tailer] Tailing: ${filePath}`);
+    } catch (err) {
+      console.error(`[file-tailer] Failed to add ${filePath}:`, (err as Error).message);
+    }
+  }
+
+  /** Serialize change processing per file to prevent duplicate reads from concurrent events */
+  private onChange(filePath: string): void {
+    const prev = this.changeQueues.get(filePath) || Promise.resolve();
+    const next = prev.then(() => this.processChange(filePath)).catch(() => {});
+    this.changeQueues.set(filePath, next);
+  }
+
+  private async processChange(filePath: string): Promise<void> {
+    const prevOffset = this.offsets.get(filePath);
+    if (prevOffset === undefined) return;
+
+    try {
+      const stat = await fsp.stat(filePath);
+      const currentSize = stat.size;
+
+      // File was truncated/rotated — reset to beginning
+      if (currentSize < prevOffset) {
+        this.offsets.set(filePath, 0);
+        this.partials.set(filePath, "");
+        return this.processChange(filePath);
+      }
+
+      // No new data
+      if (currentSize === prevOffset) return;
+
+      const bytesToRead = currentSize - prevOffset;
+      const buffer = Buffer.alloc(bytesToRead);
+
+      const fd = await fsp.open(filePath, "r");
+      try {
+        await fd.read(buffer, 0, bytesToRead, prevOffset);
+      } finally {
+        await fd.close();
+      }
+
+      this.offsets.set(filePath, currentSize);
+
+      const chunk = buffer.toString("utf-8");
+      const partial = this.partials.get(filePath) || "";
+      const combined = partial + chunk;
+      const lines = combined.split("\n");
+
+      // Last element is either empty (line ended with \n) or an incomplete line
+      this.partials.set(filePath, lines.pop()!);
+
+      if (lines.length === 0) return;
+
+      const sessionId = fileSessionId(filePath);
+      const targetPath = filetailTargetPath(this.projectPath!, filePath);
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        const parsed = parseLine(line);
+        const entry: Record<string, unknown> = {
+          type: parsed.type,
+          session: sessionId,
+          ts: parsed.ts,
+          message: parsed.message,
+          targetPath,
+          source: filePath,
+        };
+
+        recordSession(entry);
+        await this.logWriter.append(targetPath, entry);
+      }
+    } catch (err) {
+      // File may have been deleted between stat and read
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        console.error(`[file-tailer] Error reading ${filePath}:`, (err as Error).message);
+      }
+    }
+  }
+
+  /** Check if a file is a DevGlide JSONL log (has session + type fields on first line) */
+  private async isDevGlideJsonl(filePath: string): Promise<boolean> {
+    try {
+      const fd = await fsp.open(filePath, "r");
+      try {
+        const buf = Buffer.alloc(512);
+        const { bytesRead } = await fd.read(buf, 0, 512, 0);
+        if (bytesRead === 0) return false;
+        const firstLine = buf.toString("utf-8", 0, bytesRead).split("\n")[0].trim();
+        if (!firstLine.startsWith("{")) return false;
+        const obj = JSON.parse(firstLine);
+        return typeof obj.session === "string" && typeof obj.type === "string";
+      } finally {
+        await fd.close();
+      }
+    } catch {
+      return false;
+    }
+  }
+
+  private onUnlink(filePath: string): void {
+    if (this.offsets.has(filePath)) {
+      this.offsets.delete(filePath);
+      this.partials.delete(filePath);
+      this.watchedCount--;
+      console.log(`[file-tailer] Removed: ${filePath}`);
+    }
+  }
+}

package/src/apps/log/src/services/line-parser.ts

@@ -0,0 +1,94 @@
+// ── Parse raw log lines into structured entries ─────────────────────────────
+
+export interface ParsedLine {
+  type: "FILE_LOG" | "FILE_WARN" | "FILE_ERROR" | "FILE_DEBUG";
+  message: string;
+  ts: string;
+}
+
+const LEVEL_MAP: Record<string, ParsedLine["type"]> = {
+  debug: "FILE_DEBUG",
+  info: "FILE_LOG",
+  log: "FILE_LOG",
+  notice: "FILE_LOG",
+  warn: "FILE_WARN",
+  warning: "FILE_WARN",
+  error: "FILE_ERROR",
+  err: "FILE_ERROR",
+  fatal: "FILE_ERROR",
+  critical: "FILE_ERROR",
+  crit: "FILE_ERROR",
+};
+
+/**
+ * Regex for common log formats:
+ *   [2024-01-15 10:30:45] ERROR: something happened
+ *   2024-01-15T10:30:45.123Z WARN something happened
+ *   [ERROR] something happened
+ */
+const COMMON_RE =
+  /^\[?(\d{4}[-/]\d{2}[-/]\d{2}[T ]\d{2}:\d{2}:\d{2}[.\d]*Z?)\]?\s+(\w+):?\s+(.*)/;
+const LEVEL_ONLY_RE = /^\[(\w+)\]:?\s+(.*)/;
+
+function mapLevel(raw: string): ParsedLine["type"] {
+  return LEVEL_MAP[raw.toLowerCase()] || "FILE_LOG";
+}
+
+export function parseLine(raw: string): ParsedLine {
+  const trimmed = raw.trimEnd();
+  if (!trimmed) {
+    return { type: "FILE_LOG", message: "", ts: new Date().toISOString() };
+  }
+
+  // Strategy 1: JSON line
+  if (trimmed.startsWith("{")) {
+    try {
+      const obj = JSON.parse(trimmed);
+      const level =
+        obj.level || obj.severity || obj.log_level || obj.loglevel || "";
+      const message =
+        obj.msg || obj.message || obj.text || obj.body || trimmed;
+      const ts =
+        obj.time ||
+        obj.timestamp ||
+        obj.ts ||
+        obj.datetime ||
+        obj.date ||
+        new Date().toISOString();
+      return {
+        type: mapLevel(String(level)),
+        message: String(message),
+        ts: String(ts),
+      };
+    } catch {
+      // Not valid JSON — fall through
+    }
+  }
+
+  // Strategy 2: Common timestamp + level format
+  const common = COMMON_RE.exec(trimmed);
+  if (common) {
+    return {
+      type: mapLevel(common[2]),
+      message: common[3],
+      ts: common[1],
+    };
+  }
+
+  // Strategy 2b: Level-only prefix [ERROR] message
+  const levelOnly = LEVEL_ONLY_RE.exec(trimmed);
+  if (levelOnly && LEVEL_MAP[levelOnly[1].toLowerCase()]) {
+    return {
+      type: mapLevel(levelOnly[1]),
+      message: levelOnly[2],
+      ts: new Date().toISOString(),
+    };
+  }
+
+  // Strategy 3: Plain text fallback
+  return {
+    type: "FILE_LOG",
+    message: trimmed,
+    ts: new Date().toISOString(),
+  };
+}

package/src/apps/log/src/services/log-writer.ts

@@ -0,0 +1,39 @@
+import fs from "fs/promises";
+import path from "path";
+
+/**
+ * Appends JSONL log entries to files on disk.
+ * Uses per-file write queues to ensure sequential writes without corruption.
+ */
+export class LogWriter {
+  private queues = new Map<string, Promise<void>>();
+
+  async append(targetPath: string, entry: Record<string, unknown>): Promise<void> {
+    const line = JSON.stringify(entry) + "\n";
+    await this.enqueue(targetPath, async () => {
+      const dir = path.dirname(targetPath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.appendFile(targetPath, line, "utf-8");
+    });
+  }
+
+  async clear(targetPath: string): Promise<void> {
+    await this.enqueue(targetPath, async () => {
+      const dir = path.dirname(targetPath);
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(targetPath, "", "utf-8");
+    });
+  }
+
+  private enqueue(key: string, fn: () => Promise<void>): Promise<void> {
+    const prev = this.queues.get(key) || Promise.resolve();
+    const next = prev.then(fn, fn).finally(() => {
+      // Delete queue entry once it drains to prevent unbounded growth
+      if (this.queues.get(key) === next) {
+        this.queues.delete(key);
+      }
+    });
+    this.queues.set(key, next);
+    return next;
+  }
+}

package/src/apps/log/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../packages/tsconfig/node.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/src/apps/prompts/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+ WARN  Issue while reading "/home/runner/_work/devglide/devglide/.npmrc". Failed to replace env in config: ${NODE_AUTH_TOKEN}
+
+> @devglide/prompts@0.1.0 build /home/runner/_work/devglide/devglide/src/apps/prompts
+> tsc
+

package/src/apps/prompts/.turbo/turbo-lint.log

@@ -0,0 +1,24 @@
+ WARN  Issue while reading "/home/runner/_work/devglide/devglide/.npmrc". Failed to replace env in config: ${NODE_AUTH_TOKEN}
+
+> @devglide/prompts@0.1.0 lint /home/runner/_work/devglide/devglide/src/apps/prompts
+> eslint .
+
+
+/home/runner/_work/devglide/devglide/src/apps/prompts/mcp.ts
+  2:1  warning  There should be at least one empty line between import groups                                              import/order
+  3:1  warning  There should be at least one empty line between import groups                                              import/order
+  4:1  warning  `../../packages/mcp-utils/src/index.js` import should occur before import of `./services/prompt-store.js`  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/prompts/services/prompt-store.ts
+  2:1  warning  There should be at least one empty line between import groups                                   import/order
+  4:1  warning  `../../../project-context.js` import should occur before type import of `../types.js`           import/order
+  5:1  warning  `../../../packages/paths.js` import should occur before type import of `../types.js`            import/order
+  6:1  warning  `../../../packages/json-file-store.js` import should occur before type import of `../types.js`  import/order
+
+/home/runner/_work/devglide/devglide/src/apps/prompts/src/index.ts
+  2:1  warning  There should be at least one empty line between import groups           import/order
+  3:1  warning  `@devglide/mcp-utils` import should occur before import of `../mcp.js`  import/order
+
+✖ 9 problems (0 errors, 9 warnings)
+  0 errors and 9 warnings potentially fixable with the `--fix` option.
+

package/src/apps/prompts/.turbo/turbo-typecheck.log

@@ -0,0 +1,5 @@
+ WARN  Issue while reading "/home/runner/_work/devglide/devglide/.npmrc". Failed to replace env in config: ${NODE_AUTH_TOKEN}
+
+> @devglide/prompts@0.1.0 typecheck /home/runner/_work/devglide/devglide/src/apps/prompts
+> tsc --noEmit
+

package/src/apps/prompts/mcp.ts

@@ -0,0 +1,175 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { PromptStore } from './services/prompt-store.js';
+import { jsonResult, errorResult, createDevglideMcpServer } from '../../packages/mcp-utils/src/index.js';
+
+export function createPromptsMcpServer(): McpServer {
+  const server = createDevglideMcpServer(
+    'devglide-prompts',
+    '0.1.0',
+    'Reusable prompt library with variable interpolation and ratings',
+    {
+      instructions: [
+        '## Prompts — Usage Conventions',
+        '',
+        '### Purpose',
+        '- The prompt library stores reusable LLM prompt templates with {{variable}} placeholders.',
+        '- Use it to avoid rewriting the same prompt from scratch in every conversation.',
+        '',
+        '### Managing prompts',
+        '- Use `prompts_list` and `prompts_render` to reuse existing prompts before writing new ones from scratch.',
+        '- Use `prompts_get` to retrieve the full prompt including content and variables.',
+        '- Use `prompts_add` to save a new reusable prompt template.',
+        '- Use `prompts_update` to refine content, adjust rating, or add evaluation notes.',
+        '- Use `prompts_remove` to delete a prompt by ID.',
+        '- Use `prompts_context` to get all prompts as compiled markdown for LLM context injection.',
+      ],
+    },
+  );
+
+  const store = PromptStore.getInstance();
+
+  // ── 1. prompts_list ───────────────────────────────────────────────────────
+
+  server.tool(
+    'prompts_list',
+    'List all prompts. Optionally filter by category, tags, or keyword search.',
+    {
+      category: z.string().optional().describe('Filter by category'),
+      tags: z.string().optional().describe('JSON array of tags to filter by (all must match)'),
+      search: z.string().optional().describe('Text search across title, description, category, and tags'),
+    },
+    async ({ category, tags, search }) => {
+      let parsedTags: string[] | undefined;
+      if (tags) {
+        try { parsedTags = JSON.parse(tags); } catch { return errorResult('Invalid JSON for tags'); }
+      }
+      const entries = await store.list({ category, tags: parsedTags, search });
+      return jsonResult(entries);
+    },
+  );
+
+  // ── 2. prompts_get ────────────────────────────────────────────────────────
+
+  server.tool(
+    'prompts_get',
+    'Get the full prompt by ID, including content and detected variables.',
+    {
+      id: z.string().describe('Prompt ID'),
+    },
+    async ({ id }) => {
+      const entry = await store.get(id);
+      if (!entry) return errorResult(`Prompt "${id}" not found`);
+      return jsonResult(entry);
+    },
+  );
+
+  // ── 3. prompts_render ─────────────────────────────────────────────────────
+
+  server.tool(
+    'prompts_render',
+    'Render a prompt template by substituting {{varName}} placeholders with provided values.',
+    {
+      id: z.string().describe('Prompt ID'),
+      vars: z.string().optional().describe('JSON object mapping variable names to values, e.g. {"name":"World"}'),
+    },
+    async ({ id, vars }) => {
+      let parsedVars: Record<string, string> = {};
+      if (vars) {
+        try { parsedVars = JSON.parse(vars); } catch { return errorResult('Invalid JSON for vars'); }
+      }
+      const rendered = await store.render(id, parsedVars);
+      if (rendered === null) return errorResult(`Prompt "${id}" not found`);
+      return { content: [{ type: 'text' as const, text: rendered }] };
+    },
+  );
+
+  // ── 4. prompts_add ────────────────────────────────────────────────────────
+
+  server.tool(
+    'prompts_add',
+    'Add a new prompt template to the library.',
+    {
+      title: z.string().describe('Human-readable name for this prompt'),
+      content: z.string().describe('Prompt text; use {{varName}} for variable placeholders'),
+      description: z.string().optional().describe('What this prompt does'),
+      category: z.string().optional().describe('Grouping category (e.g. "code-review", "refactor")'),
+      tags: z.string().optional().describe('JSON array of tag strings'),
+      model: z.string().optional().describe('Preferred model hint (e.g. "claude-opus-4-6")'),
+      temperature: z.number().min(0).max(2).optional().describe('Preferred temperature hint'),
+      rating: z.number().int().min(1).max(5).optional().describe('Quality rating 1–5'),
+      notes: z.string().optional().describe('Evaluation notes'),
+      scope: z.enum(['project', 'global']).optional().describe('Save as project-scoped or global (default: project if active, else global)'),
+    },
+    async ({ title, content, description, category, tags, model, temperature, rating, notes, scope }) => {
+      let parsedTags: string[] = [];
+      if (tags) {
+        try { parsedTags = JSON.parse(tags); } catch { return errorResult('Invalid JSON for tags'); }
+      }
+      const entry = await store.save({ title, content, description, category, tags: parsedTags, model, temperature, rating, notes, scope });
+      return jsonResult(entry);
+    },
+  );
+
+  // ── 5. prompts_update ─────────────────────────────────────────────────────
+
+  server.tool(
+    'prompts_update',
+    'Update an existing prompt by ID.',
+    {
+      id: z.string().describe('Prompt ID'),
+      title: z.string().optional().describe('New title'),
+      content: z.string().optional().describe('New prompt content'),
+      description: z.string().nullable().optional().describe('New description (null to clear)'),
+      category: z.string().nullable().optional().describe('New category (null to clear)'),
+      tags: z.string().nullable().optional().describe('JSON array of tag strings (null to clear)'),
+      model: z.string().nullable().optional().describe('Preferred model hint (null to clear)'),
+      temperature: z.number().min(0).max(2).nullable().optional().describe('Preferred temperature (null to clear)'),
+      rating: z.number().int().min(1).max(5).nullable().optional().describe('Quality rating 1–5 (null to clear)'),
+      notes: z.string().nullable().optional().describe('Evaluation notes (null to clear)'),
+    },
+    async ({ id, title, content, description, category, tags, model, temperature, rating, notes }) => {
+      let parsedTags: string[] | null | undefined;
+      if (tags === null) {
+        parsedTags = [];
+      } else if (tags) {
+        try { parsedTags = JSON.parse(tags); } catch { return errorResult('Invalid JSON for tags'); }
+      }
+
+      const updated = await store.update(id, { title, content, description, category, tags: parsedTags, model, temperature, rating, notes });
+      if (!updated) return errorResult('Prompt not found');
+      return jsonResult(updated);
+    },
+  );
+
+  // ── 6. prompts_remove ─────────────────────────────────────────────────────
+
+  server.tool(
+    'prompts_remove',
+    'Delete a prompt by ID.',
+    {
+      id: z.string().describe('Prompt ID'),
+    },
+    async ({ id }) => {
+      const deleted = await store.delete(id);
+      if (!deleted) return errorResult('Prompt not found');
+      return jsonResult({ ok: true });
+    },
+  );
+
+  // ── 7. prompts_context ──────────────────────────────────────────────────
+
+  server.tool(
+    'prompts_context',
+    'Get all prompts as compiled markdown for LLM context injection.',
+    {},
+    async () => {
+      const markdown = await store.getCompiledContext();
+      return {
+        content: [{ type: 'text' as const, text: markdown || 'No prompts defined.' }],
+      };
+    },
+  );
+
+  return server;
+}

package/src/apps/prompts/node_modules/.bin/tsc

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/_work/devglide/devglide/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/typescript@5.9.3/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/_work/devglide/devglide/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/typescript@5.9.3/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsc" "$@"
+fi

package/src/apps/prompts/node_modules/.bin/tsserver

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/_work/devglide/devglide/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/typescript@5.9.3/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/_work/devglide/devglide/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/typescript@5.9.3/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsserver" "$@"
+else
+  exec node  "$basedir/../typescript/bin/tsserver" "$@"
+fi

package/src/apps/prompts/node_modules/.bin/tsx

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/_work/devglide/devglide/node_modules/.pnpm/tsx@4.21.0/node_modules/tsx/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/tsx@4.21.0/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/_work/devglide/devglide/node_modules/.pnpm/tsx@4.21.0/node_modules/tsx/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/tsx@4.21.0/node_modules:/home/runner/_work/devglide/devglide/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../tsx/dist/cli.mjs" "$@"
+else
+  exec node  "$basedir/../tsx/dist/cli.mjs" "$@"
+fi

package/src/apps/prompts/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@devglide/prompts",
+  "version": "0.1.0",
+  "description": "Reusable prompt library with variable interpolation and ratings",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/src/index.js",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  },
+  "private": true,
+  "dependencies": {
+    "@devglide/mcp-utils": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.25.49"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.0"
+  }
+}