@mestreyoda/fabrica 0.1.8 → 0.1.10

package/dist/index.js

@@ -111329,8 +111329,8 @@ import fsSync from "node:fs";
 import path5 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getCurrentVersion() {
-  if ("0.1.8") {
-    return "0.1.8";
+  if ("0.1.10") {
+    return "0.1.10";
   }
   try {
     const pkgPath = path5.join(THIS_DIR, "..", "..", "package.json");
@@ -142032,6 +142032,9 @@ function registerAttachmentHook(api, ctx) {
 
 // lib/dispatch/telegram-bootstrap-hook.ts
 import { homedir as homedir3 } from "node:os";
+init_runtime_paths();
+init_extract_json();
+init_zod();
 
 // lib/dispatch/telegram-bootstrap-session.ts
 init_migrate_layout();
@@ -142039,6 +142042,7 @@ import { createHash as createHash6 } from "node:crypto";
 import fs38 from "node:fs/promises";
 import path40 from "node:path";
 var SESSION_TTL_MS = 10 * 6e4;
+var CLASSIFYING_TTL_MS = 15e3;
 function sessionsDir(workspaceDir) {
   return path40.join(workspaceDir, DATA_DIR, "bootstrap-sessions");
 }
@@ -142063,14 +142067,15 @@ function buildBootstrapRequestFingerprint(input) {
 function buildBootstrapRequestHash(input) {
   return buildBootstrapRequestFingerprint(input);
 }
-function nextSuppressUntil() {
-  return new Date(Date.now() + SESSION_TTL_MS).toISOString();
+function nextSuppressUntil(status) {
+  const ttl = status === "classifying" ? CLASSIFYING_TTL_MS : SESSION_TTL_MS;
+  return new Date(Date.now() + ttl).toISOString();
 }
 async function readTelegramBootstrapSession(workspaceDir, conversationId) {
   try {
     const raw = await fs38.readFile(sessionPath(workspaceDir, conversationId), "utf-8");
     const session = JSON.parse(raw);
-    if (session.status === "clarifying" && Date.parse(session.suppressUntil) < Date.now()) {
+    if ((session.status === "clarifying" || session.status === "classifying") && Date.parse(session.suppressUntil) < Date.now()) {
       await fs38.unlink(sessionPath(workspaceDir, conversationId)).catch(() => {
       });
       return null;
@@ -142081,6 +142086,10 @@ async function readTelegramBootstrapSession(workspaceDir, conversationId) {
     throw error48;
   }
 }
+async function deleteTelegramBootstrapSession(workspaceDir, conversationId) {
+  await fs38.unlink(sessionPath(workspaceDir, conversationId)).catch(() => {
+  });
+}
 async function writeTelegramBootstrapSession(workspaceDir, session) {
   const dir = sessionsDir(workspaceDir);
   await fs38.mkdir(dir, { recursive: true });
@@ -142117,12 +142126,13 @@ async function upsertTelegramBootstrapSession(workspaceDir, input) {
     issueId: input.issueId ?? existing?.issueId ?? null,
     messageThreadId: input.messageThreadId ?? existing?.messageThreadId ?? null,
     projectChannelId: input.projectChannelId ?? existing?.projectChannelId ?? null,
+    language: input.language ?? existing?.language,
     status: input.status,
     pendingClarification: input.pendingClarification !== void 0 ? input.pendingClarification : existing?.pendingClarification ?? null,
     orphanedArtifacts: input.orphanedArtifacts !== void 0 ? input.orphanedArtifacts : existing?.orphanedArtifacts ?? null,
     createdAt: existing?.createdAt ?? now2,
     updatedAt: now2,
-    suppressUntil: nextSuppressUntil(),
+    suppressUntil: nextSuppressUntil(input.status),
     error: input.error ?? null
   };
   await writeTelegramBootstrapSession(workspaceDir, session);
@@ -142137,6 +142147,30 @@ function shouldSuppressTelegramBootstrapReply(session, request2) {
 }
 
 // lib/dispatch/telegram-bootstrap-hook.ts
+var BOOTSTRAP_MESSAGES = {
+  ack: {
+    pt: "Recebi! Vou analisar e come\xE7ar a montar o projeto...",
+    en: "Got it! I'll analyze your request and start setting up the project..."
+  },
+  clarifyStack: {
+    pt: "Qual stack voc\xEA quer usar? (Python, Node.js, Go, Java...)",
+    en: "Which stack do you want to use? (Python, Node.js, Go, Java...)"
+  },
+  clarifyBoth: {
+    pt: "Beleza! S\xF3 preciso de duas coisas pra criar:\n\n1. Qual stack? (Python, Node.js, Go, Java...)\n2. Quer dar um nome pro projeto? Se n\xE3o, eu invento um.",
+    en: "Great! I just need two things:\n\n1. Which stack? (Python, Node.js, Go, Java...)\n2. Want to name the project? If not, I'll pick one."
+  },
+  clarifyStackFollowUp: {
+    pt: "N\xE3o consegui identificar a stack. Pode me dizer qual linguagem/framework voc\xEA quer usar? Ex: Python, Node.js, Go, Java...",
+    en: "Couldn't identify the stack. Can you tell me which language/framework you'd like to use? e.g., Python, Node.js, Go, Java..."
+  },
+  registered: {
+    pt: (name, link) => `Projeto "${name}" registrado.
+Vou continuar o fluxo em ${link}`,
+    en: (name, link) => `Project "${name}" registered.
+I'll continue the flow at ${link}`
+  }
+};
 function inferProjectSlug(text) {
   const slug = text.toLowerCase().normalize("NFKD").replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 64);
   return slug || void 0;
@@ -142184,6 +142218,57 @@ function parseBootstrapRequest(text) {
     stackHint
   };
 }
+var MAX_CLASSIFY_LENGTH = 500;
+function isAmbiguousCandidate(text) {
+  const lower2 = text.toLowerCase();
+  if (lower2.length <= 20 || lower2.length > MAX_CLASSIFY_LENGTH) return false;
+  const softwareCue = /\b(projeto|project|cli|api|app|aplicativo|servi[cç]o|library|biblioteca|repo|reposit[oó]rio|tool|ferramenta|sistema|system|bot|script|programa|program)\b/.test(lower2);
+  return softwareCue;
+}
+var DmIntentSchema = external_exports.object({
+  intent: external_exports.enum(["create_project", "other"]),
+  confidence: external_exports.number().min(0).max(1),
+  stackHint: external_exports.string().nullable().optional(),
+  projectSlug: external_exports.string().nullable().optional(),
+  language: external_exports.enum(["pt", "en"]).optional().default("pt")
+});
+var CLASSIFY_PROMPT_TEMPLATE = `Classify this Telegram DM. Is the user asking to create/build a new software project, or is it something else (question, greeting, status check)?
+
+Message: "$CONTENT"
+
+Return ONLY valid JSON:
+{"intent": "create_project" | "other", "confidence": 0.0-1.0, "stackHint": "<detected stack or null>", "projectSlug": "<suggested slug or null>", "language": "pt" | "en"}
+
+Examples:
+- "Cria uma CLI Python que valida CPF" \u2192 {"intent":"create_project","confidence":0.95,"stackHint":"python-cli","projectSlug":"validador-cpf-cli","language":"pt"}
+- "Build me a REST API for tasks" \u2192 {"intent":"create_project","confidence":0.9,"stackHint":"fastapi","projectSlug":"task-api","language":"en"}
+- "How's the project going?" \u2192 {"intent":"other","confidence":0.95,"stackHint":null,"projectSlug":null,"language":"en"}
+- "Oi, tudo bem?" \u2192 {"intent":"other","confidence":0.99,"stackHint":null,"projectSlug":null,"language":"pt"}
+- "Me faz um app que converte temperaturas" \u2192 {"intent":"create_project","confidence":0.9,"stackHint":null,"projectSlug":"conversor-temperaturas","language":"pt"}`;
+async function classifyDmIntent(ctx, content, workspaceDir) {
+  try {
+    const truncated = content.slice(0, MAX_CLASSIFY_LENGTH);
+    const prompt = CLASSIFY_PROMPT_TEMPLATE.replace("$CONTENT", truncated.replace(/"/g, '\\"'));
+    const cliPath = resolveOpenClawCli({ homeDir: homedir3(), workspaceDir });
+    const sessionId = `dm-classify-${Date.now()}`;
+    const result = await ctx.runCommand(
+      [cliPath, "agent", "--local", "-m", prompt, "--session-id", sessionId, "--json"],
+      { timeoutMs: 15e3 }
+    );
+    const stdout = result.stdout ?? "";
+    if (!stdout.trim()) return null;
+    const parsed = extractJsonFromStdout(stdout);
+    if (!parsed) return null;
+    const text = parsed?.payloads?.[0]?.text;
+    const jsonStr = text ? text.replace(/^```(json)?/gm, "").replace(/```$/gm, "").trim() : JSON.stringify(parsed);
+    const intentData = JSON.parse(jsonStr);
+    const validated = DmIntentSchema.safeParse(intentData);
+    if (!validated.success) return null;
+    return validated.data;
+  } catch {
+    return null;
+  }
+}
 function isBootstrapCandidate(text) {
   const lower2 = text.toLowerCase();
   if (/^\s*(project name|nome do projeto|repository url|repo url|stack)\s*:/im.test(text)) return true;
@@ -142226,26 +142311,23 @@ function parseClarificationResponse(text, session) {
   }
   return { recognized: false };
 }
-function buildClarificationMessage(parsed, pendingClarification) {
+function buildClarificationMessage(parsed, pendingClarification, language = "pt") {
   if (pendingClarification === "stack_and_name" || !parsed.stackHint && !parsed.projectName) {
-    return `Beleza! S\xF3 preciso de duas coisas pra criar:
-
-1. Qual stack? (Python, Node.js, Go, Java...)
-2. Quer dar um nome pro projeto? Se n\xE3o, eu invento um.`;
+    return BOOTSTRAP_MESSAGES.clarifyBoth[language];
   }
-  return `Qual stack voc\xEA quer usar? (Python, Node.js, Go, Java...)`;
+  return BOOTSTRAP_MESSAGES.clarifyStack[language];
 }
 function buildFollowUpClarification(session) {
-  if (!session.stackHint) {
-    return `N\xE3o consegui identificar a stack. Pode me dizer qual linguagem/framework voc\xEA quer usar? Ex: Python, Node.js, Go, Java...`;
-  }
-  return `Pode me dar mais detalhes sobre o que voc\xEA quer construir?`;
+  const lang = session.language ?? "pt";
+  if (!session.stackHint) return BOOTSTRAP_MESSAGES.clarifyStackFollowUp[lang];
+  return lang === "en" ? "Can you give me more details about what you want to build?" : "Pode me dar mais detalhes sobre o que voc\xEA quer construir?";
 }
-function buildDmAck(projectName, topicName) {
-  return [
-    `Projeto "${projectName}" registrado.`,
-    `Vou continuar o fluxo no t\xF3pico "${topicName}" do grupo de projetos.`
-  ].join("\n");
+function buildTopicDeepLink(chatId, topicId) {
+  const stripped = chatId.replace(/^-100/, "");
+  return `https://t.me/c/${stripped}/${topicId}`;
+}
+function buildDmAck(projectName, topicLink, language = "pt") {
+  return BOOTSTRAP_MESSAGES.registered[language](projectName, topicLink);
 }
 function buildTopicKickoff(projectName, idea) {
   return [
@@ -142274,6 +142356,70 @@ function logBootstrapWarning(ctx, message) {
     ctx.logger.info(message);
   }
 }
+async function classifyAndBootstrap(ctx, workspaceDir, conversationId, content) {
+  const classification = await classifyDmIntent(ctx, content, workspaceDir);
+  if (!classification || classification.intent !== "create_project" || classification.confidence < 0.7) {
+    if (!classification) {
+      logBootstrapWarning(ctx, `[telegram-bootstrap] LLM classify failed, falling back (conversation: ${conversationId})`);
+    }
+    await deleteTelegramBootstrapSession(workspaceDir, conversationId);
+    return;
+  }
+  const language = classification.language ?? "pt";
+  await sendTelegramText(ctx, conversationId, BOOTSTRAP_MESSAGES.ack[language]);
+  const parsed = parseBootstrapRequest(content);
+  if (classification.stackHint && !parsed.stackHint) {
+    parsed.stackHint = classification.stackHint;
+  }
+  if (classification.projectSlug && !parsed.projectName) {
+    parsed.projectName = classification.projectSlug;
+  }
+  const incomingRequest = {
+    rawIdea: parsed.rawIdea,
+    projectName: parsed.projectName ?? null,
+    stackHint: parsed.stackHint ?? null,
+    repoUrl: parsed.repoUrl ?? null,
+    repoPath: parsed.repoPath ?? null
+  };
+  const incomingRequestHash = buildBootstrapRequestHash(incomingRequest);
+  const sessionForHash = await readTelegramBootstrapSession(workspaceDir, conversationId);
+  if (sessionForHash?.requestHash === incomingRequestHash) {
+    if (sessionForHash.status === "completed") {
+      ctx.logger.info(`[telegram-bootstrap] duplicate completed DM ignored (LLM path) for conversation ${conversationId}`);
+      return;
+    }
+    const isExpiredReceived = sessionForHash.status === "received" && Date.parse(sessionForHash.suppressUntil) < Date.now();
+    if (sessionForHash.status !== "failed" && sessionForHash.status !== "classifying" && !isExpiredReceived) {
+      ctx.logger.info(`[telegram-bootstrap] duplicate in-flight DM ignored (LLM path) for conversation ${conversationId}`);
+      return;
+    }
+  }
+  const sourceRoute = { channel: "telegram", channelId: conversationId };
+  const session = await upsertTelegramBootstrapSession(workspaceDir, {
+    conversationId,
+    ...incomingRequest,
+    sourceRoute,
+    sourceChannel: "telegram",
+    status: "received",
+    language
+  });
+  if (!parsed.stackHint) {
+    const pendingClarification = !parsed.projectName ? "stack_and_name" : "stack";
+    await upsertTelegramBootstrapSession(workspaceDir, {
+      conversationId,
+      ...incomingRequest,
+      sourceRoute: session.sourceRoute,
+      status: "clarifying",
+      pendingClarification,
+      language
+    });
+    await sendTelegramText(ctx, conversationId, buildClarificationMessage(parsed, pendingClarification, language));
+    return;
+  }
+  continueBootstrap(ctx, conversationId, workspaceDir, incomingRequest, sourceRoute).catch((err) => {
+    logBootstrapWarning(ctx, `[telegram-bootstrap] unhandled pipeline error (LLM path): ${err instanceof Error ? err.message : String(err)}`);
+  });
+}
 async function continueBootstrap(ctx, conversationId, workspaceDir, request2, sourceRoute) {
   const telegramConfig = readFabricaTelegramConfig(ctx.pluginConfig);
   if (!telegramConfig.projectsForumChatId) {
@@ -142429,7 +142575,8 @@ Erro: ${result.error ?? "erro desconhecido"}`
         logBootstrapWarning(ctx, `[telegram-bootstrap] immediate projectTick failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
       });
     }
-    await sendTelegramText(ctx, conversationId, buildDmAck(resolvedProjectName, `${projectChannelId}:${messageThreadId}`));
+    const sessionLang = currentSession?.language ?? "pt";
+    await sendTelegramText(ctx, conversationId, buildDmAck(resolvedProjectName, buildTopicDeepLink(String(projectChannelId), messageThreadId), sessionLang));
     await upsertTelegramBootstrapSession(workspaceDir, {
       conversationId,
       ...incomingRequest,
@@ -142478,6 +142625,18 @@ function registerTelegramBootstrapHook(api, ctx) {
       ].join("\n")
     };
   });
+  api.on("message_sending", async (_event, eventCtx) => {
+    const hookCtx = eventCtx;
+    if (hookCtx.channelId !== "telegram") return;
+    const conversationId = String(hookCtx.conversationId ?? "").trim();
+    if (!conversationId || conversationId.includes(":topic:") || conversationId.startsWith("-")) return;
+    const workspaceDir = resolveWorkspaceDir(ctx.config);
+    if (!workspaceDir) return;
+    const session = await readTelegramBootstrapSession(workspaceDir, conversationId);
+    if (session && session.status !== "completed" && session.status !== "failed" && shouldSuppressTelegramBootstrapReply(session)) {
+      return { cancel: true };
+    }
+  });
   api.on("message_received", async (event, eventCtx) => {
     if (eventCtx.channelId !== "telegram") return;
     const telegramConfig = readFabricaTelegramConfig(ctx.pluginConfig);
@@ -142495,6 +142654,10 @@ function registerTelegramBootstrapHook(api, ctx) {
     }
     const existingSession = await readTelegramBootstrapSession(workspaceDir, conversationId);
     const sessionIsExpired = existingSession != null && Date.parse(existingSession.suppressUntil) < Date.now();
+    if (existingSession && !sessionIsExpired && existingSession.status === "classifying") {
+      ctx.logger.info(`[telegram-bootstrap] LLM classification in progress for ${conversationId}, ignoring concurrent message`);
+      return;
+    }
     if (existingSession?.status === "clarifying" && !sessionIsExpired) {
       const clarResult = parseClarificationResponse(content, existingSession);
       if (!clarResult.recognized) {
@@ -142518,7 +142681,20 @@ function registerTelegramBootstrapHook(api, ctx) {
       });
       return;
     }
-    if (!isBootstrapCandidate(content)) return;
+    if (!isBootstrapCandidate(content)) {
+      if (isAmbiguousCandidate(content)) {
+        await upsertTelegramBootstrapSession(workspaceDir, {
+          conversationId,
+          rawIdea: content,
+          sourceRoute: { channel: "telegram", channelId: conversationId },
+          status: "classifying"
+        });
+        classifyAndBootstrap(ctx, workspaceDir, conversationId, content).catch((err) => {
+          logBootstrapWarning(ctx, `[telegram-bootstrap] LLM classify error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      }
+      return;
+    }
     const parsed = parseBootstrapRequest(content);
     const incomingRequest = {
       rawIdea: parsed.rawIdea,
@@ -142543,6 +142719,8 @@ function registerTelegramBootstrapHook(api, ctx) {
         ctx.logger.info(`[telegram-bootstrap] stale received session (expired) \u2014 restarting pipeline for conversation ${conversationId}`);
       }
     }
+    const language = /\b(cria|crie|criar|construa|desenvolva|registre|novo projeto)\b/i.test(content) ? "pt" : "en";
+    await sendTelegramText(ctx, conversationId, BOOTSTRAP_MESSAGES.ack[language]);
     const session = await upsertTelegramBootstrapSession(workspaceDir, {
       conversationId,
       ...incomingRequest,
@@ -142551,7 +142729,8 @@ function registerTelegramBootstrapHook(api, ctx) {
         channelId: conversationId
       },
       sourceChannel: "telegram",
-      status: "received"
+      status: "received",
+      language
     });
     if (!parsed.stackHint) {
       const pendingClarification = !parsed.projectName ? "stack_and_name" : "stack";
@@ -142560,9 +142739,10 @@ function registerTelegramBootstrapHook(api, ctx) {
         ...incomingRequest,
         sourceRoute: session.sourceRoute,
         status: "clarifying",
-        pendingClarification
+        pendingClarification,
+        language
       });
-      await sendTelegramText(ctx, conversationId, buildClarificationMessage(parsed, pendingClarification));
+      await sendTelegramText(ctx, conversationId, buildClarificationMessage(parsed, pendingClarification, language));
       return;
     }
     continueBootstrap(ctx, conversationId, workspaceDir, incomingRequest, {