prompt2task 0.1.0

package/dist/index.js

@@ -0,0 +1,1326 @@
+#!/usr/bin/env node
+import {
+  buildStructuredPrompt
+} from "./chunk-UKLTABSE.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk9 from "chalk";
+
+// src/cli/commands/init.ts
+import chalk from "chalk";
+
+// src/config/config-manager.ts
+import fs from "fs";
+import path2 from "path";
+import { z } from "zod";
+
+// src/utils/paths.ts
+import os from "os";
+import path from "path";
+function getAppDir() {
+  return path.join(os.homedir(), ".prompt2task");
+}
+function getConfigPath() {
+  return path.join(getAppDir(), "config.json");
+}
+function getDbPath() {
+  return path.join(getAppDir(), "history.db");
+}
+function getLogsDir() {
+  return path.join(getAppDir(), "logs");
+}
+function getCredentialsPath() {
+  return path.join(getAppDir(), "credentials.json");
+}
+
+// src/utils/errors.ts
+var AppError = class extends Error {
+  constructor(message, code, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.name = "AppError";
+  }
+  code;
+  hint;
+};
+var NotInitializedError = class extends AppError {
+  constructor() {
+    super(
+      "prompt2task has not been initialized. Run `prompt2task init` first.",
+      "NOT_INITIALIZED",
+      "Run: prompt2task init"
+    );
+    this.name = "NotInitializedError";
+  }
+};
+var ConfigError = class extends AppError {
+  constructor(message, hint) {
+    super(message, "CONFIG_ERROR", hint);
+    this.name = "ConfigError";
+  }
+};
+var CredentialError = class extends AppError {
+  constructor(message, hint) {
+    super(message, "CREDENTIAL_ERROR", hint);
+    this.name = "CredentialError";
+  }
+};
+var ProviderError = class extends AppError {
+  constructor(message, hint) {
+    super(message, "PROVIDER_ERROR", hint);
+    this.name = "ProviderError";
+  }
+};
+
+// src/config/config-manager.ts
+var configSchema = z.object({
+  version: z.number().default(1),
+  provider: z.enum(["openai", "claude"]),
+  model: z.string().min(1),
+  projectType: z.string().min(1)
+});
+function ensureAppDir() {
+  const dir = getAppDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+  const logsDir = path2.join(dir, "logs");
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+}
+function configExists() {
+  return fs.existsSync(getConfigPath());
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) {
+    throw new ConfigError(
+      "Configuration not found. Run `prompt2task init` to set up.",
+      "Run: prompt2task init"
+    );
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return configSchema.parse(parsed);
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      throw new ConfigError(
+        `Invalid configuration: ${err.errors.map((e) => e.message).join(", ")}`,
+        "Run `prompt2task init` to reconfigure or fix ~/.prompt2task/config.json"
+      );
+    }
+    if (err instanceof ConfigError) throw err;
+    throw new ConfigError(
+      `Failed to load configuration: ${err.message}`,
+      "Check ~/.prompt2task/config.json is valid JSON"
+    );
+  }
+}
+function saveConfig(config) {
+  ensureAppDir();
+  const parsed = configSchema.parse(config);
+  const configPath = getConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(parsed, null, 2), { mode: 384 });
+  try {
+    fs.chmodSync(configPath, 384);
+  } catch {
+  }
+}
+
+// src/config/credentials.ts
+import fs2 from "fs";
+var ENV_MAP = {
+  openai: "OPENAI_API_KEY",
+  claude: "ANTHROPIC_API_KEY"
+};
+function ensureCredentialsFile() {
+  const credPath = getCredentialsPath();
+  if (!fs2.existsSync(credPath)) {
+    return {};
+  }
+  try {
+    const raw = fs2.readFileSync(credPath, "utf-8");
+    if (!raw.trim()) return {};
+    return JSON.parse(raw);
+  } catch {
+    throw new CredentialError(
+      "Credentials file is corrupted.",
+      "Try removing ~/.prompt2task/credentials.json and re-running `prompt2task provider`"
+    );
+  }
+}
+function getCredential(provider) {
+  const envKey = ENV_MAP[provider];
+  if (envKey && process.env[envKey]) {
+    const val = process.env[envKey].trim();
+    if (val) return val;
+  }
+  const file = ensureCredentialsFile();
+  const key = file[provider];
+  if (key && typeof key === "string" && key.trim()) return key.trim();
+  return null;
+}
+function saveCredential(provider, apiKey) {
+  if (!apiKey || !apiKey.trim()) {
+    throw new CredentialError("API key cannot be empty.");
+  }
+  const dir = getAppDir();
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  const credPath = getCredentialsPath();
+  const existing = ensureCredentialsFile();
+  existing[provider] = apiKey.trim();
+  fs2.writeFileSync(credPath, JSON.stringify(existing, null, 2), { mode: 384 });
+  try {
+    fs2.chmodSync(credPath, 384);
+  } catch {
+  }
+  try {
+    fs2.chmodSync(dir, 448);
+  } catch {
+  }
+}
+function removeCredential(provider) {
+  const credPath = getCredentialsPath();
+  if (!fs2.existsSync(credPath)) return false;
+  const existing = ensureCredentialsFile();
+  if (!(provider in existing)) return false;
+  delete existing[provider];
+  fs2.writeFileSync(credPath, JSON.stringify(existing, null, 2), { mode: 384 });
+  try {
+    fs2.chmodSync(credPath, 384);
+  } catch {
+  }
+  return true;
+}
+function removeAllCredentials() {
+  const credPath = getCredentialsPath();
+  if (fs2.existsSync(credPath)) {
+    fs2.unlinkSync(credPath);
+  }
+}
+
+// src/storage/database.ts
+import fs3 from "fs";
+import path3 from "path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var { DatabaseSync } = require2("node:sqlite");
+var _db = null;
+function getDatabase(dbPath) {
+  if (_db && !dbPath) return _db;
+  const resolvedPath = dbPath ?? getDbPath();
+  const dir = path3.dirname(resolvedPath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  const logsDir = getLogsDir();
+  if (!fs3.existsSync(logsDir)) {
+    fs3.mkdirSync(logsDir, { recursive: true });
+  }
+  const sqlite = new DatabaseSync(resolvedPath);
+  runMigrations(sqlite);
+  if (!dbPath) {
+    _db = sqlite;
+  }
+  return sqlite;
+}
+function runMigrations(sqlite) {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      prompt TEXT NOT NULL,
+      status TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      project_type TEXT,
+      project_path TEXT,
+      response TEXT,
+      error TEXT,
+      created_at TEXT NOT NULL,
+      completed_at TEXT
+    );
+  `);
+}
+
+// src/cli/ui/prompts.ts
+import { select, password } from "@inquirer/prompts";
+async function promptProvider() {
+  const answer = await select({
+    message: "AI provider",
+    choices: [
+      { name: "OpenAI", value: "openai" },
+      { name: "Claude", value: "claude" }
+    ]
+  });
+  return answer;
+}
+async function promptApiKey(provider) {
+  const answer = await password({
+    message: `${provider === "openai" ? "OpenAI" : "Claude"} API Key:`,
+    mask: "*",
+    validate: (val) => val.trim().length > 0 ? true : "API key cannot be empty"
+  });
+  return answer.trim();
+}
+async function promptModel(provider) {
+  const models = provider === "openai" ? [
+    { name: "GPT-5", value: "gpt-5" },
+    { name: "GPT-5-mini", value: "gpt-5-mini" },
+    { name: "GPT-4o", value: "gpt-4o" },
+    { name: "Other", value: "__other" }
+  ] : [
+    { name: "Claude 3.5 Sonnet", value: "claude-3-5-sonnet-20241022" },
+    { name: "Claude 3.5 Haiku", value: "claude-3-5-haiku-20241022" },
+    { name: "Claude 3 Opus", value: "claude-3-opus-20240229" },
+    { name: "Other", value: "__other" }
+  ];
+  const answer = await select({
+    message: "Default model",
+    choices: models
+  });
+  if (answer === "__other") {
+    const { input } = await import("@inquirer/prompts");
+    const custom = await input({
+      message: "Enter model name:",
+      validate: (val) => val.trim() ? true : "Model cannot be empty"
+    });
+    return custom.trim();
+  }
+  return answer;
+}
+async function promptProjectType() {
+  const answer = await select({
+    message: "What do you normally build?",
+    choices: [
+      { name: "Web applications", value: "web-applications" },
+      { name: "WordPress", value: "wordpress" },
+      { name: "Laravel", value: "laravel" },
+      { name: "React", value: "react" },
+      { name: "Other", value: "other" }
+    ]
+  });
+  if (answer === "other") {
+    const { input } = await import("@inquirer/prompts");
+    const custom = await input({
+      message: "Enter project type:",
+      validate: (val) => val.trim() ? true : "Project type cannot be empty"
+    });
+    return custom.trim().toLowerCase().replace(/\s+/g, "-");
+  }
+  return answer;
+}
+
+// src/cli/ui/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({ text }).start();
+}
+
+// src/cli/commands/init.ts
+async function initCommand(options) {
+  console.log(chalk.bold("Let's get you set up.\n"));
+  const alreadyExists = configExists();
+  if (alreadyExists && !options?.force) {
+    const { confirm } = await import("@inquirer/prompts");
+    const shouldReconfigure = await confirm({
+      message: "Configuration already exists. Reconfigure?",
+      default: false
+    });
+    if (!shouldReconfigure) {
+      console.log(chalk.dim("Aborted. Existing configuration preserved."));
+      return;
+    }
+  }
+  const provider = await promptProvider();
+  let apiKey = getCredential(provider) ?? "";
+  const hasEnv = provider === "openai" ? !!process.env.OPENAI_API_KEY : !!process.env.ANTHROPIC_API_KEY;
+  if (hasEnv) {
+    console.log(chalk.dim(`Using ${provider} API key from environment variable.`));
+    apiKey = getCredential(provider);
+  } else {
+    apiKey = await promptApiKey(provider);
+    const spinner = createSpinner("Saving API key...");
+    try {
+      saveCredential(provider, apiKey);
+      spinner.succeed(chalk.green(`${provider === "openai" ? "OpenAI" : "Claude"} API key saved securely.`));
+    } catch (err) {
+      spinner.fail(chalk.red("Failed to save API key."));
+      throw err;
+    }
+  }
+  if (!hasEnv) {
+  } else {
+  }
+  const model = await promptModel(provider);
+  const projectType = await promptProjectType();
+  const spinner2 = createSpinner("Saving configuration...");
+  try {
+    ensureAppDir();
+    saveConfig({
+      version: 1,
+      provider,
+      model,
+      projectType
+    });
+    getDatabase();
+    spinner2.succeed(chalk.green("Setup complete."));
+  } catch (err) {
+    spinner2.fail(chalk.red("Failed to save configuration."));
+    throw err;
+  }
+  console.log("");
+  console.log(chalk.dim(`Config:  ~/.prompt2task/config.json`));
+  console.log(chalk.dim(`History: ~/.prompt2task/history.db`));
+}
+
+// src/cli/commands/run.ts
+import chalk2 from "chalk";
+
+// src/storage/repositories/task-repository.ts
+function rowToTask(row) {
+  return {
+    id: row.id,
+    prompt: row.prompt,
+    status: row.status,
+    provider: row.provider,
+    model: row.model,
+    projectType: row.project_type ?? void 0,
+    projectPath: row.project_path ?? void 0,
+    response: row.response ?? void 0,
+    error: row.error ?? void 0,
+    createdAt: row.created_at,
+    completedAt: row.completed_at ?? void 0
+  };
+}
+var TaskRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  create(task) {
+    const stmt = this.db.prepare(
+      `INSERT INTO tasks (id, prompt, status, provider, model, project_type, project_path, response, error, created_at, completed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    stmt.run(
+      task.id,
+      task.prompt,
+      task.status,
+      task.provider,
+      task.model,
+      task.projectType ?? null,
+      task.projectPath ?? null,
+      task.response ?? null,
+      task.error ?? null,
+      task.createdAt,
+      task.completedAt ?? null
+    );
+    return task;
+  }
+  update(id, patch) {
+    const existing = this.findById(id);
+    if (!existing) return null;
+    const fields = [];
+    const values = [];
+    if (patch.status !== void 0) {
+      fields.push("status = ?");
+      values.push(patch.status);
+    }
+    if (patch.prompt !== void 0) {
+      fields.push("prompt = ?");
+      values.push(patch.prompt);
+    }
+    if (patch.provider !== void 0) {
+      fields.push("provider = ?");
+      values.push(patch.provider);
+    }
+    if (patch.model !== void 0) {
+      fields.push("model = ?");
+      values.push(patch.model);
+    }
+    if (patch.projectType !== void 0) {
+      fields.push("project_type = ?");
+      values.push(patch.projectType);
+    }
+    if (patch.projectPath !== void 0) {
+      fields.push("project_path = ?");
+      values.push(patch.projectPath);
+    }
+    if (patch.response !== void 0) {
+      fields.push("response = ?");
+      values.push(patch.response);
+    }
+    if (patch.error !== void 0) {
+      fields.push("error = ?");
+      values.push(patch.error);
+    }
+    if (patch.completedAt !== void 0) {
+      fields.push("completed_at = ?");
+      values.push(patch.completedAt);
+    }
+    if (patch.createdAt !== void 0) {
+      fields.push("created_at = ?");
+      values.push(patch.createdAt);
+    }
+    if (fields.length > 0) {
+      const sql = `UPDATE tasks SET ${fields.join(", ")} WHERE id = ?`;
+      values.push(id);
+      this.db.prepare(sql).run(...values);
+    }
+    return this.findById(id);
+  }
+  findById(id) {
+    const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+    if (!row) return null;
+    return rowToTask(row);
+  }
+  list(options) {
+    let sql = "SELECT * FROM tasks ORDER BY created_at DESC";
+    const params = [];
+    if (options?.status) {
+      sql = "SELECT * FROM tasks WHERE status = ? ORDER BY created_at DESC";
+      params.push(options.status);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    let filtered = rows;
+    if (options?.offset) {
+      filtered = filtered.slice(options.offset);
+    }
+    if (options?.limit) {
+      filtered = filtered.slice(0, options.limit);
+    }
+    return filtered.map(rowToTask);
+  }
+  search(query, options) {
+    const pattern = `%${query}%`;
+    const rows = this.db.prepare(
+      "SELECT * FROM tasks WHERE prompt LIKE ? OR response LIKE ? ORDER BY created_at DESC"
+    ).all(pattern, pattern);
+    let result = rows.map(rowToTask);
+    if (options?.limit) result = result.slice(0, options.limit);
+    return result;
+  }
+  deleteAll() {
+    this.db.exec("DELETE FROM tasks");
+  }
+  count() {
+    const row = this.db.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
+    return row.cnt;
+  }
+};
+
+// src/utils/ids.ts
+import { randomBytes } from "crypto";
+function generateTaskId() {
+  const hex = randomBytes(5).toString("hex");
+  return `tsk_${hex}`;
+}
+
+// src/tasks/task-manager.ts
+var TaskManager = class {
+  constructor(repo) {
+    this.repo = repo;
+  }
+  repo;
+  createTask(opts) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      id: generateTaskId(),
+      prompt: opts.prompt,
+      status: "pending",
+      provider: opts.provider,
+      model: opts.model,
+      projectType: opts.projectType,
+      projectPath: opts.projectPath,
+      createdAt: now
+    };
+    this.repo.create(task);
+    return task;
+  }
+  updateStatus(id, status, patch) {
+    return this.repo.update(id, { status, ...patch });
+  }
+  async runTask(options) {
+    const { prompt, provider, model, providerName, projectType, projectContext } = options;
+    if (!prompt || !prompt.trim()) {
+      throw new Error("Prompt cannot be empty.");
+    }
+    const task = this.createTask({
+      prompt,
+      provider: providerName,
+      model,
+      projectType,
+      projectPath: projectContext?.path
+    });
+    this.repo.update(task.id, { status: "running" });
+    const structured = buildStructuredPrompt({
+      prompt,
+      projectType,
+      projectContext
+    });
+    try {
+      const response = await provider.sendTask({
+        prompt,
+        structuredPrompt: structured,
+        model,
+        projectType
+      });
+      const completed = this.repo.update(task.id, {
+        status: "completed",
+        response: response.content,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return completed ?? { ...task, status: "completed", response: response.content };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const failed = this.repo.update(task.id, {
+        status: "failed",
+        error: message,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      throw err instanceof Error ? err : new Error(message);
+    }
+  }
+};
+
+// src/providers/openai.ts
+var OpenAIProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  name = "openai";
+  getApiKey() {
+    const key = this.apiKey ?? getCredential("openai");
+    if (!key) {
+      throw new ProviderError(
+        "Missing OpenAI API key.",
+        "Set OPENAI_API_KEY env var or run `prompt2task provider`"
+      );
+    }
+    return key;
+  }
+  async validateCredentials() {
+    const key = this.getApiKey();
+    try {
+      const res = await fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${key}` }
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async sendTask(task) {
+    const key = this.getApiKey();
+    const body = {
+      model: task.model,
+      messages: [{ role: "user", content: task.structuredPrompt }]
+    };
+    let res;
+    try {
+      res = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${key}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new ProviderError(
+        `Unable to connect to OpenAI: ${err.message}`,
+        "Check your network connection"
+      );
+    }
+    if (res.status === 401) {
+      throw new ProviderError(
+        "OpenAI authentication failed. Invalid API key.",
+        "Check your API key with: prompt2task provider"
+      );
+    }
+    if (res.status === 429) {
+      throw new ProviderError(
+        "OpenAI rate limit exceeded. Please try again later.",
+        "Wait a moment and retry"
+      );
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `OpenAI request failed (${res.status}): ${text.slice(0, 500)}`
+      );
+    }
+    const data = await res.json();
+    const content = data.choices?.[0]?.message?.content ?? "";
+    if (!content) {
+      throw new ProviderError("OpenAI returned an empty response.");
+    }
+    return {
+      content,
+      model: data.model ?? task.model,
+      usage: data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      } : void 0
+    };
+  }
+};
+
+// src/providers/claude.ts
+var ClaudeProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  apiKey;
+  name = "claude";
+  getApiKey() {
+    const key = this.apiKey ?? getCredential("claude");
+    if (!key) {
+      throw new ProviderError(
+        "Missing Claude API key.",
+        "Set ANTHROPIC_API_KEY env var or run `prompt2task provider`"
+      );
+    }
+    return key;
+  }
+  async validateCredentials() {
+    const key = this.getApiKey();
+    try {
+      const res = await fetch("https://api.anthropic.com/v1/models", {
+        headers: {
+          "x-api-key": key,
+          "anthropic-version": "2023-06-01"
+        }
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async sendTask(task) {
+    const key = this.getApiKey();
+    const body = {
+      model: task.model,
+      max_tokens: 4096,
+      messages: [{ role: "user", content: task.structuredPrompt }]
+    };
+    let res;
+    try {
+      res = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": key,
+          "Content-Type": "application/json",
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new ProviderError(
+        `Unable to connect to Claude: ${err.message}`,
+        "Check your network connection"
+      );
+    }
+    if (res.status === 401) {
+      throw new ProviderError(
+        "Claude authentication failed. Invalid API key.",
+        "Check your API key with: prompt2task provider"
+      );
+    }
+    if (res.status === 429) {
+      throw new ProviderError(
+        "Claude rate limit exceeded. Please try again later."
+      );
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new ProviderError(
+        `Claude request failed (${res.status}): ${text.slice(0, 500)}`
+      );
+    }
+    const data = await res.json();
+    const textPart = data.content?.find((c) => c.type === "text");
+    const content = textPart?.text ?? "";
+    if (!content) {
+      throw new ProviderError("Claude returned an empty response.");
+    }
+    return {
+      content,
+      model: data.model ?? task.model,
+      usage: data.usage ? {
+        promptTokens: data.usage.input_tokens,
+        completionTokens: data.usage.output_tokens,
+        totalTokens: (data.usage.input_tokens ?? 0) + (data.usage.output_tokens ?? 0)
+      } : void 0
+    };
+  }
+};
+
+// src/project/detector.ts
+import fs4 from "fs";
+import path4 from "path";
+function fileExists(dir, file) {
+  return fs4.existsSync(path4.join(dir, file));
+}
+function readJsonIfExists(dir, file) {
+  const full = path4.join(dir, file);
+  if (!fs4.existsSync(full)) return null;
+  try {
+    const raw = fs4.readFileSync(full, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function detectProject(cwd = process.cwd()) {
+  const context = { path: cwd };
+  if (fileExists(cwd, "wp-config.php") || fileExists(cwd, "wp-load.php")) {
+    context.type = "wordpress";
+    context.framework = "WordPress";
+    context.language = "php";
+    return context;
+  }
+  if (fileExists(cwd, "artisan")) {
+    const composer = readJsonIfExists(cwd, "composer.json");
+    const isLaravel = composer && JSON.stringify(composer).toLowerCase().includes("laravel/framework");
+    if (isLaravel || fileExists(cwd, "composer.json")) {
+      context.type = "laravel";
+      context.framework = "Laravel";
+      context.language = "php";
+      return context;
+    }
+  }
+  if (fileExists(cwd, "composer.json")) {
+    context.type = "php";
+    context.language = "php";
+    return context;
+  }
+  const pkg = readJsonIfExists(cwd, "package.json");
+  if (pkg) {
+    const deps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    const depKeys = Object.keys(deps);
+    if (depKeys.includes("react")) {
+      context.type = "react";
+      context.framework = "React";
+      context.language = "javascript";
+      return context;
+    }
+    if (depKeys.includes("next")) {
+      context.type = "react";
+      context.framework = "Next.js";
+      context.language = "javascript";
+      return context;
+    }
+    if (depKeys.includes("vue")) {
+      context.type = "web-applications";
+      context.framework = "Vue";
+      context.language = "javascript";
+      return context;
+    }
+    if (depKeys.includes("@angular/core")) {
+      context.type = "web-applications";
+      context.framework = "Angular";
+      context.language = "javascript";
+      return context;
+    }
+    context.type = "web-applications";
+    context.framework = "Node.js";
+    context.language = "javascript";
+    return context;
+  }
+  return context;
+}
+
+// src/cli/commands/run.ts
+function getProviderInstance(name) {
+  if (name === "openai") return new OpenAIProvider();
+  if (name === "claude") return new ClaudeProvider();
+  throw new ProviderError(`Unsupported provider: ${name}`);
+}
+async function runPrompt(prompt, options = {}) {
+  if (!prompt || !prompt.trim()) {
+    console.error(chalk2.red("\u2717 Prompt cannot be empty."));
+    process.exit(1);
+  }
+  let config;
+  try {
+    config = loadConfig();
+  } catch (err) {
+    if (err instanceof NotInitializedError || err.message.includes("not been initialized")) {
+      console.error(chalk2.red("\u2717 prompt2task has not been initialized."));
+      console.error(chalk2.dim("Run `prompt2task init` first."));
+    } else {
+      console.error(chalk2.red(`\u2717 ${err.message}`));
+      if (err.hint) console.error(chalk2.dim(err.hint));
+    }
+    process.exit(1);
+  }
+  const apiKey = getCredential(config.provider);
+  if (!apiKey) {
+    console.error(chalk2.red(`\u2717 Missing API key for provider "${config.provider}".`));
+    console.error(chalk2.dim(`Set ${config.provider === "openai" ? "OPENAI_API_KEY" : "ANTHROPIC_API_KEY"} or run \`prompt2task provider\``));
+    process.exit(1);
+  }
+  const db = getDatabase();
+  const repo = new TaskRepository(db);
+  const manager = new TaskManager(repo);
+  const provider = getProviderInstance(config.provider);
+  const projectContext = detectProject(process.cwd());
+  const isJson = options.json ?? false;
+  let spinner;
+  if (!isJson) {
+    spinner = createSpinner("Creating task...");
+  }
+  let taskId = null;
+  try {
+    const task = manager.createTask({
+      prompt,
+      provider: config.provider,
+      model: config.model,
+      projectType: config.projectType,
+      projectPath: projectContext.path
+    });
+    taskId = task.id;
+    if (!isJson && spinner) {
+      spinner.succeed(chalk2.green(`Task created: ${task.id}`));
+      spinner = createSpinner(`Sending task to ${config.provider === "openai" ? "OpenAI" : "Claude"}...`);
+      repo.update(task.id, { status: "running" });
+      spinner.text = "AI is working...";
+    } else {
+      repo.update(task.id, { status: "running" });
+    }
+    const { buildStructuredPrompt: buildStructuredPrompt2 } = await import("./prompt-builder-X7TCYJ6E.js");
+    const structured = buildStructuredPrompt2({
+      prompt,
+      projectType: config.projectType,
+      projectContext
+    });
+    const response = await provider.sendTask({
+      prompt,
+      structuredPrompt: structured,
+      model: config.model,
+      projectType: config.projectType
+    });
+    repo.update(task.id, {
+      status: "completed",
+      response: response.content,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (isJson) {
+      const finalTask = repo.findById(task.id);
+      console.log(
+        JSON.stringify(
+          {
+            id: finalTask.id,
+            status: finalTask.status,
+            provider: finalTask.provider,
+            model: finalTask.model,
+            response: finalTask.response
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      if (spinner) spinner.succeed(chalk2.green("Task completed."));
+      console.log("");
+      console.log(chalk2.bold(`Task ID: ${task.id}`));
+      console.log("");
+      console.log(chalk2.bold("Response:"));
+      console.log(chalk2.dim("\u2500".repeat(40)));
+      console.log(response.content);
+      console.log(chalk2.dim("\u2500".repeat(40)));
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (taskId) {
+      try {
+        const existing = repo.findById(taskId);
+        if (existing && existing.status !== "completed") {
+          repo.update(taskId, {
+            status: "failed",
+            error: message,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      } catch {
+      }
+    }
+    if (isJson) {
+      console.log(
+        JSON.stringify(
+          {
+            id: taskId,
+            status: "failed",
+            error: message
+          },
+          null,
+          2
+        )
+      );
+      process.exit(1);
+    }
+    if (spinner) spinner.fail(chalk2.red("Task failed."));
+    console.error("");
+    console.error(chalk2.red(`\u2717 ${message}`));
+    if (err instanceof ProviderError && err.hint) {
+      console.error(chalk2.dim(err.hint));
+    } else if (message.toLowerCase().includes("authentication") || message.includes("401")) {
+      console.error(chalk2.dim("Check your API key with: prompt2task provider"));
+    }
+    if (options.debug) {
+      console.error(chalk2.dim(err.stack ?? ""));
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/list.ts
+import chalk3 from "chalk";
+
+// src/cli/ui/table.ts
+import Table from "cli-table3";
+function formatDate(iso) {
+  try {
+    const d = new Date(iso);
+    return d.toLocaleString("en-US", {
+      month: "short",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+  } catch {
+    return iso;
+  }
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+}
+function renderTaskTable(tasks) {
+  const table = new Table({
+    head: ["TASK ID", "STATUS", "CREATED", "PROMPT"],
+    colWidths: [14, 12, 18, 40],
+    wordWrap: true,
+    style: { head: [], border: [] }
+  });
+  for (const t of tasks) {
+    table.push([t.id, t.status, formatDate(t.createdAt), truncate(t.prompt, 38)]);
+  }
+  return table.toString();
+}
+
+// src/cli/commands/list.ts
+function listCommand(options) {
+  if (!configExists()) {
+    console.error(chalk3.red("\u2717 Not initialized. Run `prompt2task init` first."));
+    process.exit(1);
+  }
+  const db = getDatabase();
+  const repo = new TaskRepository(db);
+  let limit;
+  if (options.limit) {
+    limit = parseInt(options.limit, 10);
+    if (isNaN(limit) || limit <= 0) {
+      console.error(chalk3.red("\u2717 Invalid --limit value. Must be a positive number."));
+      process.exit(1);
+    }
+  }
+  let status;
+  if (options.status) {
+    const allowed = ["pending", "running", "completed", "failed", "cancelled"];
+    if (!allowed.includes(options.status)) {
+      console.error(chalk3.red(`\u2717 Invalid --status "${options.status}". Allowed: ${allowed.join(", ")}`));
+      process.exit(1);
+    }
+    status = options.status;
+  }
+  const tasks = repo.list({ limit, status });
+  if (options.json) {
+    console.log(JSON.stringify(tasks, null, 2));
+    return;
+  }
+  if (tasks.length === 0) {
+    console.log(chalk3.dim("No tasks found."));
+    return;
+  }
+  console.log(renderTaskTable(tasks));
+}
+
+// src/cli/commands/show.ts
+import chalk4 from "chalk";
+function showCommand(taskId, options) {
+  if (!configExists()) {
+    console.error(chalk4.red("\u2717 Not initialized. Run `prompt2task init` first."));
+    process.exit(1);
+  }
+  const db = getDatabase();
+  const repo = new TaskRepository(db);
+  const task = repo.findById(taskId);
+  if (!task) {
+    console.error(chalk4.red(`\u2717 Task not found: ${taskId}`));
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(task, null, 2));
+    return;
+  }
+  console.log(chalk4.bold("Task details"));
+  console.log(chalk4.dim("\u2500".repeat(40)));
+  console.log(`${chalk4.bold("Task ID:")}      ${task.id}`);
+  console.log(`${chalk4.bold("Status:")}       ${task.status}`);
+  console.log(`${chalk4.bold("Provider:")}     ${task.provider}`);
+  console.log(`${chalk4.bold("Model:")}        ${task.model}`);
+  console.log(`${chalk4.bold("Project type:")} ${task.projectType ?? "-"}`);
+  console.log(`${chalk4.bold("Project path:")} ${task.projectPath ?? "-"}`);
+  console.log(`${chalk4.bold("Created:")}      ${task.createdAt}`);
+  console.log(`${chalk4.bold("Completed:")}    ${task.completedAt ?? "-"}`);
+  console.log("");
+  console.log(chalk4.bold("Prompt:"));
+  console.log(task.prompt);
+  console.log("");
+  if (task.response) {
+    console.log(chalk4.bold("Response:"));
+    console.log(chalk4.dim("\u2500".repeat(40)));
+    console.log(task.response);
+    console.log(chalk4.dim("\u2500".repeat(40)));
+  }
+  if (task.error) {
+    console.log(chalk4.bold(chalk4.red("Error:")));
+    console.log(chalk4.red(task.error));
+  }
+}
+
+// src/cli/commands/search.ts
+import chalk5 from "chalk";
+function searchCommand(query, options) {
+  if (!configExists()) {
+    console.error(chalk5.red("\u2717 Not initialized. Run `prompt2task init` first."));
+    process.exit(1);
+  }
+  if (!query || !query.trim()) {
+    console.error(chalk5.red("\u2717 Search query cannot be empty."));
+    process.exit(1);
+  }
+  const db = getDatabase();
+  const repo = new TaskRepository(db);
+  let limit;
+  if (options.limit) {
+    limit = parseInt(options.limit, 10);
+    if (isNaN(limit) || limit <= 0) {
+      console.error(chalk5.red("\u2717 Invalid --limit value."));
+      process.exit(1);
+    }
+  }
+  const results = repo.search(query, { limit });
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  if (results.length === 0) {
+    console.log(chalk5.dim(`No tasks found for query: "${query}"`));
+    return;
+  }
+  console.log(renderTaskTable(results));
+}
+
+// src/cli/commands/config.ts
+import chalk6 from "chalk";
+function configShowCommand() {
+  if (!configExists()) {
+    console.error(chalk6.red("\u2717 Not initialized. Run `prompt2task init` first."));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  console.log(chalk6.bold("prompt2task configuration"));
+  console.log("");
+  console.log(`${chalk6.dim("Provider:")}     ${capitalize(config.provider)}`);
+  console.log(`${chalk6.dim("Model:")}        ${config.model}`);
+  console.log(`${chalk6.dim("Project type:")} ${capitalize(config.projectType)}`);
+  console.log(`${chalk6.dim("Config:")}       ${getConfigPath()}`);
+  console.log(`${chalk6.dim("History:")}      ${getDbPath()}`);
+  console.log(`${chalk6.dim("App dir:")}      ${getAppDir()}`);
+}
+function configSetCommand(key, value) {
+  if (!configExists()) {
+    console.error(chalk6.red("\u2717 Not initialized. Run `prompt2task init` first."));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const normalizedKey = key.replace(/-/g, "").toLowerCase();
+  if (normalizedKey === "model") {
+    config.model = value;
+  } else if (normalizedKey === "projecttype" || normalizedKey === "project_type") {
+    config.projectType = value;
+  } else if (normalizedKey === "provider") {
+    if (value !== "openai" && value !== "claude") {
+      console.error(chalk6.red(`\u2717 Invalid provider "${value}". Allowed: openai, claude`));
+      process.exit(1);
+    }
+    config.provider = value;
+  } else {
+    console.error(chalk6.red(`\u2717 Unknown config key "${key}". Allowed: model, project-type, provider`));
+    process.exit(1);
+  }
+  saveConfig(config);
+  console.log(chalk6.green(`\u2713 Config updated: ${key} = ${value}`));
+}
+function capitalize(s) {
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/cli/commands/provider.ts
+import chalk7 from "chalk";
+async function providerCommand() {
+  if (!configExists()) {
+    console.error(chalk7.red("\u2717 Not initialized. Run `prompt2task init` first."));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  console.log(chalk7.bold("Change provider\n"));
+  console.log(chalk7.dim(`Current: ${config.provider} / ${config.model}
+`));
+  const provider = await promptProvider();
+  const apiKey = await promptApiKey(provider);
+  const spinner = createSpinner("Saving credentials...");
+  try {
+    saveCredential(provider, apiKey);
+    spinner.succeed(chalk7.green("Credentials saved."));
+  } catch (err) {
+    spinner.fail(chalk7.red("Failed to save credentials."));
+    throw err;
+  }
+  const model = await promptModel(provider);
+  config.provider = provider;
+  config.model = model;
+  saveConfig(config);
+  console.log(chalk7.green(`
+\u2713 Provider updated to ${provider} (${model})`));
+}
+
+// src/cli/commands/credentials.ts
+import chalk8 from "chalk";
+function credentialsRemoveCommand(provider) {
+  if (!provider || provider === "all") {
+    removeAllCredentials();
+    console.log(chalk8.green("\u2713 All credentials removed."));
+    return;
+  }
+  if (provider !== "openai" && provider !== "claude") {
+    console.error(chalk8.red(`\u2717 Unknown provider "${provider}". Use: openai, claude, or all`));
+    process.exit(1);
+  }
+  const removed = removeCredential(provider);
+  if (removed) {
+    console.log(chalk8.green(`\u2713 Credentials removed for ${provider}.`));
+  } else {
+    console.log(chalk8.dim(`No credentials found for ${provider}.`));
+  }
+}
+
+// src/utils/logger.ts
+var debugEnabled = false;
+function setDebug(enabled) {
+  debugEnabled = enabled;
+}
+function debug(...args) {
+  if (debugEnabled) {
+    console.error("[debug]", ...args);
+  }
+}
+
+// src/cli/index.ts
+function createProgram() {
+  const program = new Command();
+  program.name("prompt2task").description("Turn natural-language prompts into structured tasks and send them to AI providers").version("0.1.0").option("--json", "Output result as JSON (for automation)").option("--debug", "Enable debug output").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.debug) setDebug(true);
+  });
+  program.argument("[prompt]", "Natural language prompt to execute").action(async (prompt, _opts, command) => {
+    const opts = command.optsWithGlobals();
+    if (opts.debug) setDebug(true);
+    if (!prompt) {
+      command.help();
+      return;
+    }
+    await runPrompt(prompt, { json: !!opts.json, debug: !!opts.debug });
+  });
+  program.command("init").description("Interactive first-time setup").option("-f, --force", "Force re-initialization").action(async (opts) => {
+    try {
+      await initCommand({ force: !!opts.force });
+    } catch (err) {
+      console.error(chalk9.red(`\u2717 ${err.message}`));
+      if (err.hint) console.error(chalk9.dim(err.hint));
+      process.exit(1);
+    }
+  });
+  program.command("list").description("List task history").option("--limit <n>", "Limit number of results").option("--status <status>", "Filter by status (pending, running, completed, failed, cancelled)").option("--json", "Output as JSON").action((opts) => {
+    const globalOpts = program.opts();
+    listCommand({ ...opts, json: opts.json ?? globalOpts.json });
+  });
+  program.command("show").description("Show task details").argument("<id>", "Task ID").option("--json", "Output as JSON").action((id, opts) => {
+    const globalOpts = program.opts();
+    showCommand(id, { json: opts.json ?? globalOpts.json });
+  });
+  program.command("search").description("Search tasks by prompt or response").argument("<query>", "Search query").option("--json", "Output as JSON").option("--limit <n>", "Limit results").action((query, opts) => {
+    const globalOpts = program.opts();
+    searchCommand(query, { ...opts, json: opts.json ?? globalOpts.json });
+  });
+  const configCmd = program.command("config").description("Manage configuration");
+  configCmd.action(() => {
+    configShowCommand();
+  });
+  configCmd.command("set").description("Set a config value (model, project-type, provider)").argument("<key>", "Config key").argument("<value>", "Config value").action((key, value) => {
+    configSetCommand(key, value);
+  });
+  program.command("provider").description("Change AI provider and credentials").action(async () => {
+    try {
+      await providerCommand();
+    } catch (err) {
+      console.error(chalk9.red(`\u2717 ${err.message}`));
+      process.exit(1);
+    }
+  });
+  const credentialsCmd = program.command("credentials").description("Manage credentials");
+  credentialsCmd.command("remove").description("Remove stored credentials (openai, claude, or all)").argument("[provider]", "Provider to remove").action((provider) => {
+    credentialsRemoveCommand(provider);
+  });
+  return program;
+}
+
+// src/index.ts
+async function main() {
+  const program = createProgram();
+  const rawArgs = process.argv.slice(2);
+  if (rawArgs.includes("--debug")) {
+    debug("Debug mode enabled");
+  }
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const sanitized = message.replace(/sk-[a-zA-Z0-9-_]+/g, "[REDACTED]").replace(/sk-ant-[a-zA-Z0-9-_]+/g, "[REDACTED]");
+    console.error(sanitized);
+    if (process.argv.includes("--debug") && err instanceof Error && err.stack) {
+      console.error(err.stack.replace(/sk-[a-zA-Z0-9-_]+/g, "[REDACTED]"));
+    }
+    process.exit(1);
+  }
+}
+main();