@nikitadmitrieff/feedback-chat 0.1.0

package/dist/server/index.d.ts

@@ -0,0 +1,115 @@
+import * as ai from 'ai';
+import { LanguageModel } from 'ai';
+
+type FeedbackHandlerConfig = {
+    /** Password required for authentication */
+    password: string;
+    /** AI model to use. Defaults to claude-haiku-4-5-20251001 */
+    model?: LanguageModel;
+    /** Custom system prompt. If not provided, uses buildDefaultPrompt with projectContext */
+    systemPrompt?: string;
+    /** Project context passed to buildDefaultPrompt (ignored if systemPrompt is provided) */
+    projectContext?: string;
+    /** GitHub configuration for issue creation */
+    github?: {
+        token: string;
+        repo: string;
+        labels?: string[];
+    };
+};
+/**
+ * Creates a Next.js App Router POST handler for the feedback chat.
+ * Returns `{ POST }` ready to be exported from a route.ts file.
+ */
+declare function createFeedbackHandler(config: FeedbackHandlerConfig): {
+    POST: (req: Request) => Promise<Response>;
+};
+
+type StatusHandlerConfig = {
+    /** Password required for POST actions */
+    password: string;
+    /** GitHub configuration. If not provided, reads from GITHUB_TOKEN / GITHUB_REPO env vars */
+    github?: {
+        token: string;
+        repo: string;
+    };
+    /** Agent URL for checking if the agent is currently running a job */
+    agentUrl?: string;
+};
+type Stage = 'created' | 'queued' | 'running' | 'validating' | 'preview_ready' | 'deployed' | 'failed' | 'rejected';
+type StatusResponse = {
+    stage: Stage;
+    issueNumber: number;
+    issueUrl: string;
+    failReason?: string;
+    previewUrl?: string;
+    prNumber?: number;
+    prUrl?: string;
+};
+/**
+ * Creates Next.js App Router GET and POST handlers for the feedback status endpoint.
+ * Returns `{ GET, POST }` ready to be exported from a route.ts file.
+ *
+ * GET /api/feedback/status?issue=N — returns current pipeline stage
+ * POST /api/feedback/status?action=retry|approve|reject|request_changes&issue=N — performs action
+ */
+declare function createStatusHandler(config: StatusHandlerConfig): {
+    GET: (req: Request) => Promise<Response>;
+    POST: (req: Request) => Promise<Response>;
+};
+
+/**
+ * Default system prompt for the feedback chatbot.
+ * Generalized English version of the original French prompt.
+ */
+declare function buildDefaultPrompt(projectContext?: string): string;
+
+/**
+ * Function signature for creating a GitHub issue.
+ * Returns the issue URL on success, or null if GitHub is not configured.
+ */
+type GitHubIssueCreator = (params: {
+    title: string;
+    body: string;
+    labels?: string[];
+}) => Promise<string | null>;
+/**
+ * Creates the feedback chatbot tool definitions.
+ * Uses dependency injection for the GitHub issue creator.
+ */
+declare function createTools(createIssue?: GitHubIssueCreator): {
+    present_options: ai.Tool<{
+        options: string[];
+    }, {
+        presented: boolean;
+        count: number;
+    }>;
+    submit_request: ai.Tool<{
+        summary: string;
+        prompt_type: "simple" | "ralph_loop";
+        generated_prompt: string;
+        spec_content?: string | undefined;
+        visitor_name?: string | undefined;
+    }, {
+        success: boolean;
+        github_issue_url: string;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        github_issue_url?: undefined;
+    }>;
+};
+
+/**
+ * GitHub issue creator.
+ * Reads GITHUB_TOKEN and GITHUB_REPO from environment variables.
+ * Returns null gracefully if env vars are missing.
+ */
+declare function createGitHubIssue({ title, body, labels, }: {
+    title: string;
+    body: string;
+    labels?: string[];
+}): Promise<string | null>;
+
+export { type FeedbackHandlerConfig, type GitHubIssueCreator, type Stage, type StatusHandlerConfig, type StatusResponse, buildDefaultPrompt, createFeedbackHandler, createGitHubIssue, createStatusHandler, createTools };

package/dist/server/index.js

@@ -0,0 +1,548 @@
+// src/server/handler.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import {
+  convertToModelMessages,
+  stepCountIs,
+  streamText
+} from "ai";
+
+// src/server/default-prompt.ts
+function buildDefaultPrompt(projectContext) {
+  const contextBlock = projectContext ? `## Project Context
+${projectContext}` : "(No project context provided.)";
+  return `You are a product advisor embedded in an application. You speak to non-technical users who have ideas for improving the product. Your role: understand their need, guide them with your knowledge of the product, and turn their idea into a precise request.
+
+${contextBlock}
+
+## Your Approach
+
+You are NOT a form. You are an advisor who knows the product inside out. When someone brings up an idea, you:
+- **Understand the deeper intent** behind the request, not just the words
+- **Propose concrete solutions** building on what already exists in the product
+- **Explain what you envision** so the person can say "yes that's it" or "no, more like this"
+- **Anticipate implications** \u2014 if someone wants to change one feature, you know what else it might affect
+
+### How You Guide the Conversation
+
+**From the very first message**, rephrase the idea with your own understanding of the product and propose a direction:
+- "Great idea! Currently the product has [description]. What I'd suggest is [concrete proposal]. Does that sound right?"
+- "I see what you mean. We could do this two ways: [option A] or [option B]. Which feels better to you?"
+
+**If the idea is vague**, don't ask "can you clarify?" \u2014 instead propose concrete directions.
+
+**IMPORTANT \u2014 presenting choices:** When you want to offer options to the user, call the \`present_options\` tool with an array of options. Do NOT list options as numbered text \u2014 always use the tool so the interface displays clickable buttons.
+
+**If the idea is clear**, confirm quickly and move to submission without unnecessary questions.
+
+### Being Proactive
+
+- If the request is small, suggest complementary improvements: "While we're changing [X], should we also [Y]?"
+- Explain why your proposal is good: "I'd suggest [alternative] because [product-related reason]"
+- If you see a potential issue, mention it kindly: "Heads up \u2014 if we do this we'd also need to think about [consequence]"
+- Give visual examples when possible: "Imagine a blue card with a large title and a button below it"
+
+## Submission
+
+When you agree on the request, summarize in 2-3 simple sentences what will be done, then call submit_request.
+
+## Rules
+- Keep a warm and enthusiastic tone (you love when people suggest ideas)
+- Match the user's formality level
+- NEVER use technical jargon \u2014 no "component", "API", "database", "route", "state", "responsive"
+- 2 to 3 exchanges maximum \u2014 if it's clear from the start, submit after 1 exchange
+- Skip steps already covered when the person gives a lot of detail at once
+
+## Rules for the Generated Prompt
+- generated_prompt is ALWAYS in English (it's for the development tool)
+- summary should be in the user's language (it's for the human)
+- Small change -> prompt_type: "simple" \u2014 clear description, relevant files, expected outcome
+- Large change (new page, new system) -> prompt_type: "ralph_loop" \u2014 high-level description + spec_content with Goal, numbered Tasks, Acceptance Criteria
+- Always mention specific files to modify when you know them (refer to the project context above)
+- The prompt must be detailed enough for a developer to implement without extra context`;
+}
+
+// src/server/tools.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createTools(createIssue) {
+  return {
+    present_options: tool({
+      description: "Present clickable options to the user for selection. Use this whenever you want to offer choices instead of writing numbered lists. After calling this tool, end your message briefly \u2014 the user will click an option to continue.",
+      inputSchema: z.object({
+        options: z.array(z.string()).min(2).max(5).describe("The options to present as clickable buttons")
+      }),
+      execute: async ({ options }) => ({ presented: true, count: options.length })
+    }),
+    submit_request: tool({
+      description: "Submit the finalized feedback request with a generated prompt for Claude Code.",
+      inputSchema: z.object({
+        summary: z.string().describe("Brief summary of the request"),
+        prompt_type: z.enum(["simple", "ralph_loop"]).describe(
+          "simple for small changes, ralph_loop for large features"
+        ),
+        generated_prompt: z.string().describe("The generated prompt in English for Claude Code"),
+        spec_content: z.string().optional().describe(
+          "Markdown spec content for ralph_loop type requests"
+        ),
+        visitor_name: z.string().optional().describe("Name of the person making the request")
+      }),
+      execute: async (args) => {
+        const bodyParts = [
+          `## Generated Prompt
+
+\`\`\`
+${args.generated_prompt}
+\`\`\``
+        ];
+        if (args.spec_content) {
+          bodyParts.push(`## Spec Content
+
+${args.spec_content}`);
+        }
+        bodyParts.push(
+          `## Metadata
+
+- **Type:** ${args.prompt_type}
+- **Submitted by:** ${args.visitor_name || "Anonymous"}`
+        );
+        const agentMeta = JSON.stringify({
+          prompt_type: args.prompt_type,
+          visitor_name: args.visitor_name || "Anonymous"
+        });
+        bodyParts.push(`<!-- agent-meta: ${agentMeta} -->`);
+        const issueBody = bodyParts.join("\n\n");
+        if (createIssue) {
+          const githubUrl = await createIssue({
+            title: `[Feedback] ${args.summary}`,
+            body: issueBody,
+            labels: ["feedback-bot", "auto-implement"]
+          });
+          if (githubUrl) {
+            return { success: true, github_issue_url: githubUrl };
+          }
+        }
+        return { success: true, message: "Saved locally" };
+      }
+    })
+  };
+}
+
+// src/server/github.ts
+async function createGitHubIssue({
+  title,
+  body,
+  labels = ["feedback-bot"]
+}) {
+  const token = process.env.GITHUB_TOKEN;
+  const repo = process.env.GITHUB_REPO;
+  if (!token || !repo) {
+    return null;
+  }
+  try {
+    const response = await fetch(
+      `https://api.github.com/repos/${repo}/issues`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: "application/vnd.github+json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ title, body, labels })
+      }
+    );
+    if (!response.ok) {
+      console.error("GitHub issue creation failed:", response.status);
+      return null;
+    }
+    const data = await response.json();
+    return data.html_url;
+  } catch (error) {
+    console.error("GitHub issue creation error:", error);
+    return null;
+  }
+}
+
+// src/server/handler.ts
+function createFeedbackHandler(config) {
+  const POST = async (req) => {
+    const { messages, password } = await req.json();
+    if (password !== config.password) {
+      return Response.json({ error: "Invalid password" }, { status: 401 });
+    }
+    if (!messages.length) {
+      return Response.json({ ok: true });
+    }
+    const model = config.model ?? createAnthropic()("claude-haiku-4-5-20251001");
+    const systemPrompt = config.systemPrompt ?? buildDefaultPrompt(config.projectContext);
+    let issueCreator;
+    if (config.github) {
+      const { token, repo, labels } = config.github;
+      issueCreator = async (params) => {
+        const mergedLabels = [
+          .../* @__PURE__ */ new Set([...labels ?? [], ...params.labels ?? []])
+        ];
+        try {
+          const response = await fetch(
+            `https://api.github.com/repos/${repo}/issues`,
+            {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/vnd.github+json",
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                title: params.title,
+                body: params.body,
+                labels: mergedLabels
+              })
+            }
+          );
+          if (!response.ok) return null;
+          const data = await response.json();
+          return data.html_url;
+        } catch {
+          return null;
+        }
+      };
+    } else {
+      issueCreator = createGitHubIssue;
+    }
+    const tools = createTools(issueCreator);
+    const result = streamText({
+      model,
+      system: systemPrompt,
+      messages: await convertToModelMessages(messages),
+      stopWhen: stepCountIs(2),
+      tools
+    });
+    return result.toUIMessageStreamResponse();
+  };
+  return { POST };
+}
+
+// src/server/status-handler.ts
+var GITHUB_API = "https://api.github.com/repos";
+function issueEndpoint(config, issueNumber) {
+  return `${GITHUB_API}/${config.repo}/issues/${issueNumber}`;
+}
+function parseIssueNumber(param) {
+  if (!param) return null;
+  const n = parseInt(param, 10);
+  return isNaN(n) ? null : n;
+}
+function githubHeaders(token, withBody = false) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json"
+  };
+  if (withBody) {
+    headers["Content-Type"] = "application/json";
+  }
+  return headers;
+}
+async function getIssue(config, issueNumber) {
+  const res = await fetch(issueEndpoint(config, issueNumber), {
+    headers: githubHeaders(config.token),
+    cache: "no-store"
+  });
+  if (!res.ok) return null;
+  return res.json();
+}
+async function findPR(config, issueNumber) {
+  const [owner] = config.repo.split("/");
+  const res = await fetch(
+    `${GITHUB_API}/${config.repo}/pulls?head=${owner}:feedback/issue-${issueNumber}&state=open`,
+    { headers: githubHeaders(config.token), cache: "no-store" }
+  );
+  if (!res.ok) return null;
+  const pulls = await res.json();
+  if (!Array.isArray(pulls) || pulls.length === 0) return null;
+  const pr = pulls[0];
+  return { number: pr.number, html_url: pr.html_url, head_sha: pr.head?.sha };
+}
+async function getPreviewUrl(config, sha) {
+  const res = await fetch(
+    `${GITHUB_API}/${config.repo}/deployments?sha=${sha}&per_page=5`,
+    { headers: githubHeaders(config.token), cache: "no-store" }
+  );
+  if (!res.ok) return null;
+  const deployments = await res.json();
+  if (!Array.isArray(deployments)) return null;
+  for (const deployment of deployments) {
+    const statusRes = await fetch(deployment.statuses_url, {
+      headers: githubHeaders(config.token),
+      cache: "no-store"
+    });
+    if (!statusRes.ok) continue;
+    const statuses = await statusRes.json();
+    const success = statuses.find(
+      (s) => s.state === "success" && s.environment_url
+    );
+    if (success) return success.environment_url;
+  }
+  return null;
+}
+async function getFailReason(config, issueNumber) {
+  const res = await fetch(
+    `${issueEndpoint(config, issueNumber)}/comments?per_page=5&direction=desc`,
+    { headers: githubHeaders(config.token), cache: "no-store" }
+  );
+  if (!res.ok) return void 0;
+  const comments = await res.json();
+  const failComment = comments.find(
+    (c) => c.body?.startsWith("Agent failed:")
+  );
+  return failComment?.body?.replace("Agent failed:", "").trim();
+}
+async function isAgentRunning(agentUrl, issueNumber) {
+  if (!agentUrl) return false;
+  try {
+    const res = await fetch(`${agentUrl}/health`, { cache: "no-store" });
+    if (!res.ok) return false;
+    const data = await res.json();
+    return data.currentJob === issueNumber;
+  } catch {
+    return false;
+  }
+}
+async function deriveStage(config, issueNumber, agentUrl) {
+  const issue = await getIssue(config, issueNumber);
+  if (!issue) return null;
+  const labels = (issue.labels ?? []).map((l) => l.name);
+  const issueUrl = issue.html_url;
+  if (labels.includes("agent-failed")) {
+    const failReason = await getFailReason(config, issueNumber);
+    return { stage: "failed", issueUrl, failReason };
+  }
+  if (labels.includes("rejected")) {
+    return { stage: "rejected", issueUrl };
+  }
+  if (issue.state === "closed") {
+    return { stage: "deployed", issueUrl };
+  }
+  if (await isAgentRunning(agentUrl, issueNumber)) {
+    return { stage: "running", issueUrl };
+  }
+  if (labels.includes("preview-pending")) {
+    const pr = await findPR(config, issueNumber);
+    if (pr) {
+      const previewUrl = await getPreviewUrl(config, pr.head_sha);
+      if (previewUrl) {
+        return {
+          stage: "preview_ready",
+          issueUrl,
+          previewUrl,
+          prNumber: pr.number,
+          prUrl: pr.html_url
+        };
+      }
+    }
+    return { stage: "validating", issueUrl };
+  }
+  if (labels.includes("in-progress")) {
+    return { stage: "validating", issueUrl };
+  }
+  if (labels.includes("feedback-bot")) {
+    return { stage: "queued", issueUrl };
+  }
+  return { stage: "created", issueUrl };
+}
+async function closeAndReopenIssue(url, headers) {
+  const closeRes = await fetch(url, {
+    method: "PATCH",
+    headers,
+    body: JSON.stringify({ state: "closed" })
+  });
+  if (!closeRes.ok) {
+    return Response.json({ error: "Failed to close issue" }, { status: 500 });
+  }
+  await new Promise((resolve) => setTimeout(resolve, 1e3));
+  const reopenRes = await fetch(url, {
+    method: "PATCH",
+    headers,
+    body: JSON.stringify({ state: "open" })
+  });
+  if (!reopenRes.ok) {
+    return Response.json({ error: "Failed to reopen issue" }, { status: 500 });
+  }
+  return null;
+}
+function deleteFeedbackBranch(config, issueNumber, headers) {
+  return fetch(
+    `${GITHUB_API}/${config.repo}/git/refs/heads/feedback/issue-${issueNumber}`,
+    { method: "DELETE", headers }
+  );
+}
+async function handleRetry(config, issueNumber) {
+  const headers = githubHeaders(config.token, true);
+  const url = issueEndpoint(config, issueNumber);
+  for (const label of ["agent-failed", "in-progress"]) {
+    const res = await fetch(`${url}/labels/${encodeURIComponent(label)}`, {
+      method: "DELETE",
+      headers
+    });
+    if (!res.ok && res.status !== 404) {
+      return Response.json({ error: "Failed to remove labels" }, { status: 500 });
+    }
+  }
+  const error = await closeAndReopenIssue(url, headers);
+  if (error) return error;
+  return Response.json({ retried: true });
+}
+async function handleApprove(config, issueNumber) {
+  const headers = githubHeaders(config.token, true);
+  const url = issueEndpoint(config, issueNumber);
+  const pr = await findPR(config, issueNumber);
+  if (!pr) {
+    return Response.json({ error: "Pull request not found" }, { status: 404 });
+  }
+  const mergeRes = await fetch(
+    `${GITHUB_API}/${config.repo}/pulls/${pr.number}/merge`,
+    {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({ merge_method: "squash" })
+    }
+  );
+  if (!mergeRes.ok) {
+    if (mergeRes.status === 409) {
+      return Response.json(
+        { error: "Merge conflict \u2014 contact administrator" },
+        { status: 409 }
+      );
+    }
+    return Response.json({ error: "Merge failed" }, { status: 500 });
+  }
+  await fetch(url, {
+    method: "PATCH",
+    headers,
+    body: JSON.stringify({ state: "closed" })
+  });
+  await deleteFeedbackBranch(config, issueNumber, headers);
+  return Response.json({ approved: true });
+}
+async function handleReject(config, issueNumber) {
+  const headers = githubHeaders(config.token, true);
+  const url = issueEndpoint(config, issueNumber);
+  const pr = await findPR(config, issueNumber);
+  if (pr) {
+    await fetch(`${GITHUB_API}/${config.repo}/pulls/${pr.number}`, {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify({ state: "closed" })
+    });
+  }
+  await fetch(`${url}/labels`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ labels: ["rejected"] })
+  });
+  await fetch(url, {
+    method: "PATCH",
+    headers,
+    body: JSON.stringify({ state: "closed" })
+  });
+  await deleteFeedbackBranch(config, issueNumber, headers);
+  return Response.json({ rejected: true });
+}
+async function handleRequestChanges(config, issueNumber, comment) {
+  const headers = githubHeaders(config.token, true);
+  const url = issueEndpoint(config, issueNumber);
+  if (comment) {
+    await fetch(`${url}/comments`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ body: `**Changes requested:**
+
+${comment}` })
+    });
+  }
+  await fetch(`${url}/labels/${encodeURIComponent("preview-pending")}`, {
+    method: "DELETE",
+    headers
+  });
+  await fetch(`${url}/labels`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ labels: ["auto-implement"] })
+  });
+  const error = await closeAndReopenIssue(url, headers);
+  if (error) return error;
+  return Response.json({ requested_changes: true });
+}
+var VALID_ACTIONS = ["retry", "approve", "reject", "request_changes"];
+function resolveGitHubConfig(config) {
+  if (config.github) {
+    return config.github;
+  }
+  const repo = process.env.GITHUB_REPO;
+  const token = process.env.GITHUB_TOKEN;
+  if (!repo || !token) return null;
+  return { repo, token };
+}
+function resolveAgentUrl(config) {
+  return config.agentUrl ?? process.env.AGENT_URL;
+}
+function createStatusHandler(config) {
+  const GET = async (req) => {
+    const url = new URL(req.url);
+    const issueNumber = parseIssueNumber(url.searchParams.get("issue"));
+    if (!issueNumber) {
+      return Response.json({ error: "Missing or invalid issue parameter" }, { status: 400 });
+    }
+    const ghConfig = resolveGitHubConfig(config);
+    if (!ghConfig) {
+      return Response.json({ error: "GitHub not configured" }, { status: 500 });
+    }
+    const agentUrl = resolveAgentUrl(config);
+    const result = await deriveStage(ghConfig, issueNumber, agentUrl);
+    if (!result) {
+      return Response.json({ error: "Issue not found" }, { status: 404 });
+    }
+    const response = { issueNumber, ...result };
+    return Response.json(response);
+  };
+  const POST = async (req) => {
+    const url = new URL(req.url);
+    const action = url.searchParams.get("action");
+    if (!action || !VALID_ACTIONS.includes(action)) {
+      return Response.json({ error: "Invalid action" }, { status: 400 });
+    }
+    const issueNumber = parseIssueNumber(url.searchParams.get("issue"));
+    if (!issueNumber) {
+      return Response.json({ error: "Missing or invalid issue parameter" }, { status: 400 });
+    }
+    let body = {};
+    try {
+      body = await req.json();
+    } catch {
+    }
+    if (!config.password || body.password !== config.password) {
+      return Response.json({ error: "Invalid password" }, { status: 401 });
+    }
+    const ghConfig = resolveGitHubConfig(config);
+    if (!ghConfig) {
+      return Response.json({ error: "GitHub not configured" }, { status: 500 });
+    }
+    switch (action) {
+      case "retry":
+        return handleRetry(ghConfig, issueNumber);
+      case "approve":
+        return handleApprove(ghConfig, issueNumber);
+      case "reject":
+        return handleReject(ghConfig, issueNumber);
+      case "request_changes":
+        return handleRequestChanges(ghConfig, issueNumber, body.comment);
+    }
+  };
+  return { GET, POST };
+}
+export {
+  buildDefaultPrompt,
+  createFeedbackHandler,
+  createGitHubIssue,
+  createStatusHandler,
+  createTools
+};