@inteeka/task-cli 0.2.24 → 0.2.26

package/dist/cli.js

@@ -3997,6 +3997,239 @@ function clampInt(raw, min, max, fallback) {
   return Math.min(v, max);
 }
 
+// src/commands/slack-import.ts
+import { spawn as spawn5 } from "child_process";
+import { request as request5 } from "undici";
+var BULLET_TYPES = ["bug", "feature", "task", "question", "improvement"];
+var BULLET_PRIORITIES = ["critical", "high", "medium", "low", "none"];
+var CLASSIFICATIONS = ["code", "physical"];
+var BULLETS_SCHEMA = {
+  type: "object",
+  required: ["bullets"],
+  additionalProperties: false,
+  properties: {
+    bullets: {
+      type: "array",
+      maxItems: 200,
+      items: {
+        type: "object",
+        required: ["title", "description", "type", "priority", "classification"],
+        additionalProperties: false,
+        properties: {
+          title: { type: "string", minLength: 1, maxLength: 500 },
+          description: { type: "string", minLength: 1, maxLength: 8e3 },
+          type: { type: "string", enum: BULLET_TYPES },
+          priority: { type: "string", enum: BULLET_PRIORITIES },
+          classification: { type: "string", enum: CLASSIFICATIONS },
+          reason: { type: "string", maxLength: 500 }
+        }
+      }
+    }
+  }
+};
+var SYSTEM_PROMPT = `You convert raw Slack call notes into a list of actionable tickets, one per concrete action item.
+
+For each bullet decide:
+- classification = "code" if the item requires changes to the team's software (bug fixes, feature work, refactors, deploys, infra/config changes that a developer would do).
+- classification = "physical" if it is a human action that doesn't touch the codebase (sending an email, calling a vendor, booking a meeting, writing a non-code doc, scheduling someone's time, follow-ups, status updates).
+
+When in doubt, prefer "physical". A false-positive "code" ticket wastes AI budget and pollutes the dev queue. A false-positive "physical" ticket still gets tracked and a human can re-classify.
+
+For each ticket also choose:
+- type: bug | feature | task | question | improvement (task is the safe default)
+- priority: critical | high | medium | low | none (medium is the safe default)
+
+The "reason" field is a brief 1-sentence explanation of WHY you classified the bullet this way \u2014 useful for the team reviewing the import. Keep it under 500 chars.
+
+Drop greetings, social chatter, recaps that aren't actionable, and anything that is purely informational. Each bullet must be a concrete action someone has to do.
+
+Return JSON only, matching the supplied schema. No prose, no markdown fences, no commentary.`;
+var SLACK_IMPORT_MODEL = "claude-sonnet-4-6";
+function sanitiseNotes(raw) {
+  return raw.replace(/ignore\s+(all\s+)?previous\s+instructions/gi, "[REDACTED]").replace(/system\s*:\s*/gi, "[REDACTED]");
+}
+function registerSlackImport(program2) {
+  program2.command("slack-import").description(
+    "Internal: parse Slack call notes (from stdin) into classified bullets and PATCH them back to a slack_imports row. Spawned by the listener \u2014 not for direct human use."
+  ).requiredOption("--import-id <uuid>", "Slack-import row id (from the webhook payload)").requiredOption("--organisation-id <uuid>", "Organisation id of the import").requiredOption("--project-id <uuid>", "Project id of the import").requiredOption("--update-url <url>", "Absolute callback URL for PATCH status updates").option(
+    "--notes-stdin",
+    "Read raw notes from stdin (default; the listener passes them this way)"
+  ).option("--notes <text>", "Inline notes for local testing (mutually exclusive with stdin)").option("--claude-path <path>", "Override the claude binary path").action(async (opts) => {
+    await runSlackImport(opts);
+  });
+}
+async function runSlackImport(opts) {
+  let creds = await readCredentials();
+  if (!creds) {
+    throw new CliError(
+      CLI_EXIT_CODES.MISCONFIGURATION,
+      "Not signed in",
+      "Run 'task login' on this host so the listener can PATCH back."
+    );
+  }
+  creds = await ensureFreshAccessToken(creds);
+  await patchStatus(opts.updateUrl, creds.access_token, { status: "processing" }).catch((err) => {
+    process.stderr.write(`[slack-import] processing PATCH failed: ${err.message}
+`);
+  });
+  const rawNotes = await readNotes(opts);
+  if (!rawNotes.trim()) {
+    await patchStatus(opts.updateUrl, creds.access_token, {
+      status: "failed",
+      error_message: "No notes provided on stdin"
+    });
+    throw new CliError(CLI_EXIT_CODES.GENERIC_ERROR, "No notes provided");
+  }
+  let bullets;
+  try {
+    bullets = await generateBullets({
+      notes: sanitiseNotes(rawNotes),
+      claudePath: opts.claudePath
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    await patchStatus(opts.updateUrl, creds.access_token, {
+      status: "failed",
+      error_message: msg.slice(0, 2e3)
+    }).catch(() => void 0);
+    throw new CliError(CLI_EXIT_CODES.GENERIC_ERROR, `Bullet generation failed: ${msg}`);
+  }
+  const result = await patchStatus(opts.updateUrl, creds.access_token, {
+    status: "completed",
+    bullets
+  });
+  process.stdout.write(
+    `${c.ok("\u2713")} slack-import ${opts.importId.slice(0, 8)}\u2026 \u2014 ${bullets.length} bullets (${result.code_count ?? 0} code, ${result.physical_count ?? 0} physical)
+`
+  );
+}
+async function readNotes(opts) {
+  if (opts.notes !== void 0) return opts.notes;
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of process.stdin) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += buf.length;
+    if (total > 6e4) {
+      throw new CliError(CLI_EXIT_CODES.GENERIC_ERROR, "Notes exceed 60KB");
+    }
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function generateBullets(args) {
+  const claude = args.claudePath ?? "claude";
+  const cliArgs = [
+    "--print",
+    "--output-format",
+    "json",
+    "--tools",
+    "",
+    "--system-prompt",
+    SYSTEM_PROMPT,
+    "--model",
+    SLACK_IMPORT_MODEL,
+    "--json-schema",
+    JSON.stringify(BULLETS_SCHEMA)
+  ];
+  return new Promise((resolve2, reject) => {
+    let child;
+    try {
+      child = spawn5(claude, cliArgs, { stdio: ["pipe", "pipe", "pipe"] });
+    } catch (err) {
+      reject(new Error(`Could not invoke claude: ${err.message}`));
+      return;
+    }
+    let stdoutBuf = "";
+    let stderrBuf = "";
+    child.stdout?.on("data", (b) => stdoutBuf += b.toString("utf8"));
+    child.stderr?.on("data", (b) => stderrBuf += b.toString("utf8"));
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(
+          new Error(
+            `claude exited ${code}${stderrBuf.trim() ? ": " + stderrBuf.trim().slice(0, 500) : ""}`
+          )
+        );
+        return;
+      }
+      const extracted = extractStructured(stdoutBuf);
+      if (!extracted.ok) {
+        reject(new Error(extracted.error));
+        return;
+      }
+      const list = extracted.value.bullets;
+      if (!Array.isArray(list)) {
+        reject(new Error("claude returned no bullets array"));
+        return;
+      }
+      const out = [];
+      for (const b of list) {
+        const cls = b["classification"];
+        if (cls !== "code" && cls !== "physical") continue;
+        const title = typeof b["title"] === "string" ? b["title"].slice(0, 500) : "";
+        const description = typeof b["description"] === "string" ? b["description"].slice(0, 8e3) : "";
+        if (!title || !description) continue;
+        const type2 = BULLET_TYPES.includes(b["type"]) ? b["type"] : "task";
+        const priority = BULLET_PRIORITIES.includes(b["priority"]) ? b["priority"] : "medium";
+        const item = { title, description, type: type2, priority, classification: cls };
+        if (typeof b["reason"] === "string") item.reason = b["reason"].slice(0, 500);
+        out.push(item);
+      }
+      resolve2(out);
+    });
+    child.stdin?.write(args.notes);
+    child.stdin?.end();
+  });
+}
+function extractStructured(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return { ok: false, error: "claude returned empty stdout" };
+  try {
+    const env = JSON.parse(trimmed);
+    if (env.is_error === true) {
+      const code = typeof env.error_code === "string" ? env.error_code : "unknown";
+      const result = typeof env.result === "string" ? env.result.slice(0, 400) : "";
+      return { ok: false, error: `claude is_error (${code}): ${result || "no detail"}` };
+    }
+    if (env.structured_output && typeof env.structured_output === "object") {
+      return { ok: true, value: env.structured_output };
+    }
+    if (typeof env.result === "string") {
+      const m = env.result.match(/\{[\s\S]*\}/);
+      if (m) return { ok: true, value: JSON.parse(m[0]) };
+    }
+  } catch {
+  }
+  try {
+    const m = trimmed.match(/\{[\s\S]*\}/);
+    if (m) return { ok: true, value: JSON.parse(m[0]) };
+  } catch {
+  }
+  return { ok: false, error: "claude returned no parseable JSON" };
+}
+async function patchStatus(url, bearer, body) {
+  const res = await request5(url, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${bearer}`
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await res.body.text();
+  if (res.statusCode >= 400) {
+    throw new Error(`PATCH ${url} \u2192 ${res.statusCode}: ${text.slice(0, 400)}`);
+  }
+  try {
+    const parsed = JSON.parse(text);
+    return parsed.data ?? {};
+  } catch {
+    return {};
+  }
+}
+
 // src/commands/fast-track.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import ora3 from "ora";
@@ -4390,7 +4623,7 @@ import { platform as platform2 } from "os";
 import { mkdir as mkdir9, readFile as readFile5, writeFile as writeFile10, unlink as unlink4, readdir as readdir2 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { join as join11 } from "path";
-import { execFileSync as execFileSync9, spawn as spawn5 } from "child_process";
+import { execFileSync as execFileSync9, spawn as spawn6 } from "child_process";
 
 // src/scheduler/cron-translate.ts
 function translateToLaunchd(cron) {
@@ -4608,7 +4841,7 @@ var launchdAdapter = {
     return new Promise((resolve2) => {
       const args = entry.command.match(/(?:[^\s"]+|"[^"]*")+/g) ?? [entry.command];
       const cmd = args.shift() ?? entry.command;
-      const child = spawn5(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn6(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
       let stdoutTail = "";
       let stderrTail = "";
       child.stdout?.on("data", (chunk) => {
@@ -4654,7 +4887,7 @@ var launchdAdapter = {
 };
 
 // src/scheduler/cron.ts
-import { execFileSync as execFileSync10, spawn as spawn6 } from "child_process";
+import { execFileSync as execFileSync10, spawn as spawn7 } from "child_process";
 
 // src/scheduler/safe-command.ts
 var FORBIDDEN = /[;&|`$()<>\\]/;
@@ -4715,7 +4948,7 @@ function readCrontab() {
   }
 }
 function writeCrontab(text) {
-  const child = spawn6("crontab", ["-"], { stdio: ["pipe", "inherit", "inherit"] });
+  const child = spawn7("crontab", ["-"], { stdio: ["pipe", "inherit", "inherit"] });
   child.stdin.write(text);
   child.stdin.end();
 }
@@ -4796,7 +5029,7 @@ var cronAdapter = {
       return Promise.resolve({ exitCode: 1, stdoutTail: "", stderrTail: `rejected: ${reason}` });
     }
     return new Promise((resolve2) => {
-      const child = spawn6(parsed.bin, parsed.args, { stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn7(parsed.bin, parsed.args, { stdio: ["ignore", "pipe", "pipe"] });
       let stdoutTail = "";
       let stderrTail = "";
       child.stdout?.on(
@@ -4824,7 +5057,7 @@ var cronAdapter = {
 };
 
 // src/scheduler/windows.ts
-import { execFileSync as execFileSync11, spawn as spawn7 } from "child_process";
+import { execFileSync as execFileSync11, spawn as spawn8 } from "child_process";
 var TASK_PREFIX = "TaskCLI_";
 function taskName(id) {
   return `${TASK_PREFIX}${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
@@ -4937,7 +5170,7 @@ var windowsAdapter = {
       return Promise.resolve({ exitCode: 1, stdoutTail: "", stderrTail: `rejected: ${reason}` });
     }
     return new Promise((resolve2) => {
-      const child = spawn7(parsed.bin, parsed.args, { stdio: ["ignore", "pipe", "pipe"] });
+      const child = spawn8(parsed.bin, parsed.args, { stdio: ["ignore", "pipe", "pipe"] });
       let stdoutTail = "";
       let stderrTail = "";
       child.stdout?.on(
@@ -5365,7 +5598,7 @@ function registerConfig(program2) {
 import { execFileSync as execFileSync12 } from "child_process";
 import { readFile as readFile8, writeFile as writeFile12 } from "fs/promises";
 import { join as join14 } from "path";
-import { request as request5 } from "undici";
+import { request as request6 } from "undici";
 var ALLOWED_TEST_EXECUTABLES = /* @__PURE__ */ new Set(["pnpm", "npm", "yarn", "bun", "node", "npx"]);
 var DEFAULT_TEST_COMMAND = "pnpm typecheck";
 function registerDoctor(program2) {
@@ -5406,7 +5639,7 @@ function registerDoctor(program2) {
     });
     const apiUrl = creds?.api_url ?? cfg.api_url;
     try {
-      const res = await request5(apiUrl, {
+      const res = await request6(apiUrl, {
         method: "GET",
         headersTimeout: 5e3,
         bodyTimeout: 5e3
@@ -5663,7 +5896,7 @@ function checkBinary(name, command) {
 }
 
 // src/commands/version.ts
-var CLI_VERSION = true ? "0.2.24" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.2.26" : "0.0.0-dev";
 function registerVersion(program2) {
   program2.command("version").description("Print the CLI version").action(() => {
     process.stdout.write(CLI_VERSION + "\n");
@@ -5690,6 +5923,7 @@ registerMultiWork(program);
 registerResume(program);
 registerReset(program);
 registerScan(program);
+registerSlackImport(program);
 registerFastTrack(program);
 registerPrTest(program);
 registerScheduledTask(program);