@jxtools/promptline 1.0.0

package/README.md

@@ -0,0 +1,45 @@
+# PromptLine
+
+A prompt queue system for Claude Code.
+
+Ever been watching Claude Code work and thought of three more things you need it to do next? PromptLine lets you line up those prompts so Claude picks them up automatically — one after another, without missing a single detail.
+
+## Install
+
+```bash
+npm install -g @jxtools/promptline
+```
+
+## Usage
+
+```bash
+promptline
+```
+
+On first run, PromptLine asks to install its hooks into Claude Code. After that, it opens the dashboard.
+
+## How it works
+
+Start your Claude Code sessions as usual. Then open PromptLine in a separate terminal — it detects all running sessions automatically.
+
+While Claude is working, add prompts to the queue from the dashboard. When Claude finishes its current task, it picks up the next queued prompt and keeps going. Each session has its own independent queue, so multiple sessions in the same project don't interfere with each other.
+
+1. **Work with Claude Code** — Start your sessions normally
+2. **Open PromptLine** — Run `promptline` in a separate terminal
+3. **Queue your prompts** — Add them while Claude works, they execute in order
+
+## Update
+
+```bash
+promptline update
+```
+
+## Requirements
+
+- Node.js 18+
+- Python 3
+- Claude Code installed
+
+## License
+
+ISC

package/bin/promptline.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync, writeFileSync, copyFileSync, chmodSync } from 'fs'
+import { resolve, dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+import { spawn, execSync } from 'child_process'
+import { createInterface } from 'readline'
+import { homedir } from 'os'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const pkgDir = resolve(__dirname, '..')
+const pkg = JSON.parse(readFileSync(resolve(pkgDir, 'package.json'), 'utf-8'))
+
+// --version
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+  console.log(`promptline v${pkg.version}`)
+  process.exit(0)
+}
+
+// update
+if (process.argv[2] === 'update') {
+  const current = pkg.version
+  console.log(`\x1b[36m⟳\x1b[0m Current version: v${current}`)
+  console.log(`  Checking for updates...`)
+
+  try {
+    const latest = execSync('npm view @jxtools/promptline version', { encoding: 'utf-8' }).trim()
+
+    if (latest === current) {
+      console.log(`\x1b[32m✓\x1b[0m Already on the latest version (v${current})`)
+      process.exit(0)
+    }
+
+    console.log(`\x1b[33m↑\x1b[0m New version available: v${latest}`)
+    console.log(`  Updating...`)
+
+    execSync('npm install -g @jxtools/promptline@latest', { stdio: 'inherit' })
+    console.log(`\n\x1b[32m✓\x1b[0m Updated to v${latest}`)
+  } catch (err) {
+    console.error(`\x1b[31m✗\x1b[0m Update failed: ${err.message}`)
+    process.exit(1)
+  }
+
+  process.exit(0)
+}
+
+// Check Claude Code is installed
+const claudeDir = join(homedir(), '.claude')
+if (!existsSync(claudeDir)) {
+  console.error('\x1b[31m✗\x1b[0m Claude Code not found. Install it first.')
+  process.exit(1)
+}
+
+// Check hooks installation
+const hooksDir = join(claudeDir, 'hooks')
+const hookFiles = [
+  'promptline-session-register.sh',
+  'promptline-prompt-queue.sh',
+  'promptline-session-end.sh',
+]
+
+const allHooksInstalled = hookFiles.every(f => existsSync(join(hooksDir, f)))
+
+if (!allHooksInstalled) {
+  const answer = await ask('Install PromptLine hooks for Claude Code? (Y/n) ')
+
+  if (answer.toLowerCase() === 'n') {
+    console.log('  Skipped. Run promptline again to install later.')
+    process.exit(0)
+  }
+
+  installHooks()
+}
+
+// Start Vite dev server
+const viteBin = resolve(pkgDir, 'node_modules', '.bin', 'vite')
+const vite = spawn(viteBin, [], {
+  cwd: pkgDir,
+  stdio: ['ignore', 'pipe', 'pipe'],
+  env: { ...process.env, FORCE_COLOR: '0' },
+})
+
+let opened = false
+const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '')
+
+vite.stdout.on('data', (data) => {
+  const line = stripAnsi(data.toString())
+  const match = line.match(/localhost:(\d+)/)
+
+  if (match && !opened) {
+    opened = true
+    const port = match[1]
+    const url = `http://localhost:${port}`
+    console.log(`\x1b[32m✓\x1b[0m PromptLine running at \x1b[36m${url}\x1b[0m`)
+    console.log(`  Press \x1b[33mCtrl+C\x1b[0m to stop\n`)
+  }
+})
+
+vite.stderr.on('data', (data) => {
+  const line = data.toString().trim()
+  if (line && !line.includes('ExperimentalWarning')) {
+    process.stderr.write(data)
+  }
+})
+
+vite.on('close', (code) => process.exit(code ?? 0))
+
+process.on('SIGINT', () => {
+  vite.kill('SIGINT')
+  console.log('\n\x1b[33m⏹\x1b[0m PromptLine stopped.')
+  process.exit(0)
+})
+
+// --- Helpers ---
+
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve(answer.trim() || 'y')
+    })
+  })
+}
+
+function installHooks() {
+  // Copy hook scripts
+  execSync(`mkdir -p "${hooksDir}"`)
+
+  for (const file of hookFiles) {
+    const src = join(pkgDir, file)
+    const dest = join(hooksDir, file)
+    copyFileSync(src, dest)
+    chmodSync(dest, 0o755)
+  }
+
+  // Merge into settings.json
+  const settingsPath = join(claudeDir, 'settings.json')
+  let settings = {}
+
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf-8'))
+    } catch {
+      // corrupted settings, start fresh
+    }
+  }
+
+  if (!settings.hooks) settings.hooks = {}
+
+  const hookConfig = {
+    SessionStart: {
+      file: 'promptline-session-register.sh',
+    },
+    Stop: {
+      file: 'promptline-prompt-queue.sh',
+    },
+    SessionEnd: {
+      file: 'promptline-session-end.sh',
+    },
+  }
+
+  for (const [event, config] of Object.entries(hookConfig)) {
+    const command = `~/.claude/hooks/${config.file}`
+
+    if (!settings.hooks[event]) settings.hooks[event] = []
+
+    const alreadyExists = settings.hooks[event].some(entry =>
+      entry.hooks?.some(h => h.command === command)
+    )
+
+    if (!alreadyExists) {
+      settings.hooks[event].push({
+        hooks: [{ type: 'command', command }],
+      })
+    }
+  }
+
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n')
+  console.log(`\x1b[32m✓\x1b[0m Hooks installed`)
+}

package/index.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>⚡</text></svg>" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <title>PromptLine</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@jxtools/promptline",
+  "version": "1.0.0",
+  "type": "module",
+  "license": "ISC",
+  "bin": {
+    "promptline": "./bin/promptline.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "promptline-*.sh",
+    "vite-plugin-api.ts",
+    "vite.config.ts",
+    "tsconfig.json",
+    "tsconfig.app.json",
+    "tsconfig.node.json",
+    "index.html",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@tailwindcss/vite": "^4.2.1",
+    "@vitejs/plugin-react": "^5.1.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "tailwindcss": "^4.2.1",
+    "typescript": "~5.9.3",
+    "uuid": "^13.0.0",
+    "vite": "^7.3.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@types/uuid": "^10.0.0",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "typescript-eslint": "^8.48.0",
+    "vitest": "^4.0.18"
+  }
+}

package/promptline-prompt-queue.sh

@@ -0,0 +1,173 @@
+#!/bin/bash
+# promptline-prompt-queue.sh — Stop hook for Claude Code.
+# Reads from ~/.promptline/queues/{project}/{session_id}.json.
+# If a pending prompt exists, outputs {"decision":"block","reason":"..."}
+# so Claude continues with the next queued prompt.
+# If no pending prompts remain, exits 0 (Claude stops normally).
+
+set -euo pipefail
+
+# --- Read Claude Code hook input from stdin ---
+INPUT=$(cat)
+
+# --- Extract session_id, cwd, and transcript_path from input JSON ---
+PARSED=$(echo "$INPUT" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+print(data.get('session_id', ''))
+print(data.get('cwd', ''))
+print(data.get('transcript_path', ''))
+print(data.get('stop_hook_active', False))
+" 2>/dev/null) || PARSED=$'\n\n\n'
+
+SESSION_ID=$(echo "$PARSED" | sed -n '1p')
+CWD=$(echo "$PARSED" | sed -n '2p')
+TRANSCRIPT_PATH=$(echo "$PARSED" | sed -n '3p')
+STOP_HOOK_ACTIVE=$(echo "$PARSED" | sed -n '4p')
+
+# If no cwd, nothing to do
+if [ -z "$CWD" ]; then
+  exit 0
+fi
+
+# --- Derive project name and session file path ---
+PROJECT=$(basename "$CWD")
+QUEUE_DIR="$HOME/.promptline/queues/$PROJECT"
+QUEUE_FILE="$QUEUE_DIR/$SESSION_ID.json"
+
+export QUEUE_FILE SESSION_ID CWD PROJECT TRANSCRIPT_PATH STOP_HOOK_ACTIVE
+
+# No session file -> nothing to do (SessionStart hook handles registration)
+if [ ! -f "$QUEUE_FILE" ]; then
+  exit 0
+fi
+
+# --- Process queue with python3 ---
+RESULT=$(python3 << 'PYEOF'
+import json
+import sys
+import os
+import tempfile
+from datetime import datetime, timezone
+
+def atomic_write(path, obj):
+    """Write JSON atomically: temp file + rename to prevent corruption."""
+    dir_name = os.path.dirname(path)
+    fd, tmp_path = tempfile.mkstemp(dir=dir_name, suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(obj, f, indent=2)
+        os.replace(tmp_path, path)
+    except Exception:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+def extract_session_name(transcript_path, max_len=50):
+    """Extract first user message from transcript JSONL as session name."""
+    if not transcript_path or not os.path.isfile(transcript_path):
+        return None
+    try:
+        with open(transcript_path, "r") as f:
+            for line in f:
+                try:
+                    entry = json.loads(line.strip())
+                    if entry.get("type") == "user":
+                        msg = entry.get("message", {})
+                        content = msg.get("content", "")
+                        if isinstance(content, str) and content.strip():
+                            text = content.strip().replace("\n", " ")
+                            return text[:max_len] + "..." if len(text) > max_len else text
+                        elif isinstance(content, list):
+                            for part in content:
+                                if isinstance(part, dict) and part.get("type") == "text":
+                                    text = part.get("text", "").strip().replace("\n", " ")
+                                    if text:
+                                        return text[:max_len] + "..." if len(text) > max_len else text
+                except (json.JSONDecodeError, KeyError):
+                    continue
+    except (IOError, OSError):
+        pass
+    return None
+
+queue_file = os.environ.get("QUEUE_FILE", "")
+session_id = os.environ.get("SESSION_ID", "")
+transcript_path = os.environ.get("TRANSCRIPT_PATH", "")
+
+if not queue_file or not os.path.isfile(queue_file):
+    print("STOP")
+    sys.exit(0)
+
+try:
+    with open(queue_file, "r") as f:
+        data = json.load(f)
+except (json.JSONDecodeError, IOError):
+    print("0")
+    sys.exit(0)
+
+prompts = data.get("prompts", [])
+now = datetime.now(timezone.utc).isoformat()
+
+# Step 1: Mark any currently "running" prompts as "completed"
+for p in prompts:
+    if p.get("status") == "running":
+        p["status"] = "completed"
+        p["completedAt"] = now
+
+# Step 1b: Track completedAt when all prompts are done
+all_done = all(p.get("status") == "completed" for p in prompts) and len(prompts) > 0
+if all_done and not data.get("completedAt"):
+    data["completedAt"] = now
+
+# Step 1c: Update sessionName if still null
+if not data.get("sessionName"):
+    data["sessionName"] = extract_session_name(transcript_path)
+
+# Step 2: Find the first "pending" prompt
+next_prompt = None
+for p in prompts:
+    if p.get("status") == "pending":
+        next_prompt = p
+        break
+
+# Step 3: Update session tracking
+data["lastActivity"] = now
+
+if next_prompt is None:
+    data["prompts"] = prompts
+    data["currentPromptId"] = None
+    atomic_write(queue_file, data)
+    print("STOP")
+    sys.exit(0)
+
+# We have a pending prompt -> mark it as running
+next_prompt["status"] = "running"
+data["currentPromptId"] = next_prompt["id"]
+data["prompts"] = prompts
+
+atomic_write(queue_file, data)
+
+# Count remaining pending prompts (excluding the one we just took)
+remaining = sum(1 for p in prompts if p.get("status") == "pending")
+
+reason = f"PromptLine ({remaining} queued)\n\n{next_prompt['text']}"
+decision = {"decision": "block", "reason": reason}
+print("CONTINUE")
+print(json.dumps(decision))
+PYEOF
+)
+
+# --- Handle python output ---
+ACTION=$(echo "$RESULT" | head -n1)
+
+if [ "$ACTION" = "CONTINUE" ]; then
+  # Output JSON decision on stdout so Claude Code continues with next prompt.
+  # Safe from infinite loops: the queue drains (pending -> running -> completed)
+  # and the hook exits 0 without blocking when no prompts remain.
+  echo "$RESULT" | sed '1d'
+  exit 0
+fi
+
+exit 0

package/promptline-session-end.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# promptline-session-end.sh
+# SessionEnd hook: marks a session as closed when Claude Code exits.
+# Updates closedAt and lastActivity in ~/.promptline/queues/{project}/{session_id}.json
+
+set -euo pipefail
+
+INPUT=$(cat)
+
+PARSED=$(echo "$INPUT" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+print(data.get('session_id', ''))
+print(data.get('cwd', ''))
+" 2>/dev/null) || PARSED=$'\n'
+
+SESSION_ID=$(echo "$PARSED" | sed -n '1p')
+CWD=$(echo "$PARSED" | sed -n '2p')
+
+if [ -z "$CWD" ] || [ -z "$SESSION_ID" ]; then
+  exit 0
+fi
+
+PROJECT=$(basename "$CWD")
+QUEUE_FILE="$HOME/.promptline/queues/$PROJECT/$SESSION_ID.json"
+export QUEUE_FILE
+
+python3 << 'PYEOF'
+import json, os, tempfile
+from datetime import datetime, timezone
+
+def atomic_write(path, obj):
+    dir_name = os.path.dirname(path)
+    fd, tmp_path = tempfile.mkstemp(dir=dir_name, suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(obj, f, indent=2)
+        os.replace(tmp_path, path)
+    except Exception:
+        try: os.unlink(tmp_path)
+        except OSError: pass
+        raise
+
+queue_file = os.environ["QUEUE_FILE"]
+now = datetime.now(timezone.utc).isoformat()
+
+try:
+    with open(queue_file, "r") as f:
+        data = json.load(f)
+    data["closedAt"] = now
+    data["lastActivity"] = now
+    atomic_write(queue_file, data)
+except (json.JSONDecodeError, IOError, OSError):
+    pass
+
+PYEOF
+
+exit 0

package/promptline-session-register.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+# promptline-session-register.sh
+# SessionStart hook: auto-creates per-session queue file when Claude Code opens.
+# Stores at ~/.promptline/queues/{project}/{session_id}.json
+# Extracts session name from the transcript's first user message.
+
+set -euo pipefail
+
+INPUT=$(cat)
+
+PARSED=$(echo "$INPUT" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+print(data.get('session_id', ''))
+print(data.get('cwd', ''))
+print(data.get('transcript_path', ''))
+" 2>/dev/null) || PARSED=$'\n\n'
+
+SESSION_ID=$(echo "$PARSED" | sed -n '1p')
+CWD=$(echo "$PARSED" | sed -n '2p')
+TRANSCRIPT_PATH=$(echo "$PARSED" | sed -n '3p')
+
+if [ -z "$CWD" ] || [ -z "$SESSION_ID" ]; then
+  exit 0
+fi
+
+PROJECT=$(basename "$CWD")
+QUEUE_DIR="$HOME/.promptline/queues/$PROJECT"
+QUEUE_FILE="$QUEUE_DIR/$SESSION_ID.json"
+
+mkdir -p "$QUEUE_DIR"
+
+export QUEUE_FILE SESSION_ID CWD PROJECT TRANSCRIPT_PATH
+
+python3 << 'PYEOF'
+import json, os, tempfile
+from datetime import datetime, timezone
+
+def atomic_write(path, obj):
+    dir_name = os.path.dirname(path)
+    fd, tmp_path = tempfile.mkstemp(dir=dir_name, suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(obj, f, indent=2)
+        os.replace(tmp_path, path)
+    except Exception:
+        try: os.unlink(tmp_path)
+        except OSError: pass
+        raise
+
+def extract_session_name(transcript_path, max_len=50):
+    """Extract first user message from transcript JSONL as session name."""
+    if not transcript_path or not os.path.isfile(transcript_path):
+        return None
+    try:
+        with open(transcript_path, "r") as f:
+            for line in f:
+                try:
+                    entry = json.loads(line.strip())
+                    if entry.get("type") == "user":
+                        msg = entry.get("message", {})
+                        content = msg.get("content", "")
+                        if isinstance(content, str) and content.strip():
+                            text = content.strip().replace("\n", " ")
+                            return text[:max_len] + "..." if len(text) > max_len else text
+                        elif isinstance(content, list):
+                            for part in content:
+                                if isinstance(part, dict) and part.get("type") == "text":
+                                    text = part.get("text", "").strip().replace("\n", " ")
+                                    if text:
+                                        return text[:max_len] + "..." if len(text) > max_len else text
+                except (json.JSONDecodeError, KeyError):
+                    continue
+    except (IOError, OSError):
+        pass
+    return None
+
+queue_file = os.environ["QUEUE_FILE"]
+session_id = os.environ["SESSION_ID"]
+cwd = os.environ["CWD"]
+project = os.environ["PROJECT"]
+transcript_path = os.environ.get("TRANSCRIPT_PATH", "")
+now = datetime.now(timezone.utc).isoformat()
+
+if os.path.isfile(queue_file):
+    try:
+        with open(queue_file, "r") as f:
+            data = json.load(f)
+        data["lastActivity"] = now
+        if not data.get("sessionName"):
+            data["sessionName"] = extract_session_name(transcript_path)
+        atomic_write(queue_file, data)
+    except (json.JSONDecodeError, IOError):
+        pass
+else:
+    session_name = extract_session_name(transcript_path)
+    data = {
+        "sessionId": session_id,
+        "project": project,
+        "directory": cwd,
+        "sessionName": session_name,
+        "prompts": [],
+        "startedAt": now,
+        "lastActivity": now,
+        "currentPromptId": None,
+        "completedAt": None,
+        "closedAt": None,
+    }
+    atomic_write(queue_file, data)
+
+PYEOF
+
+exit 0