alphamilk 0.0.1

package/dist/cli.js

@@ -0,0 +1,424 @@
+#!/usr/bin/env node
+// src/cli.ts
+import { Command, Options, Args } from "@effect/cli";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { FetchHttpClient } from "@effect/platform";
+import { Console as Console2, Effect as Effect3, Layer, Logger, LogLevel } from "effect";
+
+// src/config.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "alphamilk");
+var SESSION_FILE = path.join(CONFIG_DIR, "session.json");
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function saveSession(config) {
+  ensureConfigDir();
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(config, null, 2));
+}
+function loadSession() {
+  if (!fs.existsSync(SESSION_FILE)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(SESSION_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (new Date(parsed.expiresAt) < /* @__PURE__ */ new Date()) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function clearSession() {
+  if (fs.existsSync(SESSION_FILE)) {
+    fs.unlinkSync(SESSION_FILE);
+  }
+}
+
+// src/api.ts
+import { Effect, Data } from "effect";
+import { HttpClient, HttpClientRequest } from "@effect/platform";
+var CLI_VERSION = "0.0.1";
+var ApiError = class extends Data.TaggedError("ApiError") {
+};
+var apiGet = (baseUrl, path3, params) => Effect.gen(function* () {
+  const client = yield* HttpClient.HttpClient;
+  const url = new URL(path3, baseUrl);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0 && v !== "") {
+        url.searchParams.set(k, v);
+      }
+    }
+  }
+  const request = HttpClientRequest.get(url.toString()).pipe(
+    HttpClientRequest.setHeader("X-AlphaMilk-Client", "cli"),
+    HttpClientRequest.setHeader("X-AlphaMilk-CLI-Version", CLI_VERSION)
+  );
+  const response = yield* client.execute(request).pipe(Effect.scoped);
+  const body = yield* response.text;
+  if (response.status >= 400) {
+    return yield* Effect.fail(new ApiError({ statusCode: response.status, message: body }));
+  }
+  return body;
+});
+var apiPost = (baseUrl, path3, body) => Effect.gen(function* () {
+  const client = yield* HttpClient.HttpClient;
+  const url = new URL(path3, baseUrl);
+  const request = HttpClientRequest.post(url.toString()).pipe(
+    HttpClientRequest.setHeader("X-AlphaMilk-Client", "cli"),
+    HttpClientRequest.setHeader("X-AlphaMilk-CLI-Version", CLI_VERSION),
+    HttpClientRequest.bodyUnsafeJson(body)
+  );
+  const response = yield* client.execute(request).pipe(Effect.scoped);
+  const responseBody = yield* response.text;
+  if (response.status >= 400) {
+    return yield* Effect.fail(new ApiError({ statusCode: response.status, message: responseBody }));
+  }
+  return responseBody;
+});
+
+// src/helpers.ts
+import { Console, Effect as Effect2 } from "effect";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+var parseSessionId = (markdown) => {
+  const match = markdown.match(/\*\*Session ID\*\*\s*\|\s*`([^`]+)`/);
+  return match ? match[1] : null;
+};
+var parseExpiresAt = (markdown) => {
+  const match = markdown.match(/\*\*Expires\*\*\s*\|\s*(\S+)/);
+  return match ? match[1] : null;
+};
+var readReportFile = (filePath) => Effect2.gen(function* () {
+  const resolved = path2.resolve(filePath);
+  if (!fs2.existsSync(resolved)) {
+    yield* Console.error(
+      `File not found: ${resolved}
+
+Check the path and try again. Use an absolute path or a path relative to your current directory.
+
+Example:
+  alphamilk report save --name "My Report" --file ./report.md
+  alphamilk report save --name "My Report" --file /tmp/report.md`
+    );
+    return yield* Effect2.die("File not found");
+  }
+  let fileContent;
+  try {
+    fileContent = fs2.readFileSync(resolved, "utf-8");
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    yield* Console.error(
+      `Cannot read file: ${resolved}
+
+Error: ${msg}
+
+Check file permissions and try again.`
+    );
+    return yield* Effect2.die("File read error");
+  }
+  if (fileContent.trim().length === 0) {
+    yield* Console.error(
+      `File is empty: ${resolved}
+
+The report file must contain markdown content. Write your report to the file first, then run this command.
+
+Example workflow:
+  1. Write your report to report.md
+  2. alphamilk report save --name "My Report" --file ./report.md`
+    );
+    return yield* Effect2.die("Empty file");
+  }
+  return fileContent;
+});
+
+// src/cli.ts
+var BASE_URL = "https://alphamilk.ai";
+var exitWithError = (message) => Console2.error(message).pipe(
+  Effect3.flatMap(() => Effect3.sync(() => process.exit(1)))
+);
+var requireSession = Effect3.gen(function* () {
+  const session = loadSession();
+  if (!session) {
+    return yield* exitWithError(
+      "No active session. Run `alphamilk login --token <tokenId>` first."
+    );
+  }
+  return session;
+});
+var handleApiError = (context) => Effect3.catchAll((e) => {
+  const msg = e instanceof Error ? e.message : String(e);
+  return exitWithError(`${context}: ${msg}`);
+});
+var loginToken = Options.text("token").pipe(
+  Options.withAlias("t"),
+  Options.withDescription("Your Alpha Milk access token ID")
+);
+var loginCommand = Command.make(
+  "login",
+  { token: loginToken },
+  ({ token }) => Effect3.gen(function* () {
+    yield* Console2.log(`Authenticating with token: ${token.slice(0, 8)}...`);
+    const response = yield* apiGet(BASE_URL, `/milk/create-session/${token}`).pipe(
+      handleApiError("Login failed")
+    );
+    const sessionId = parseSessionId(response);
+    const expiresAt = parseExpiresAt(response);
+    if (!sessionId) {
+      return yield* exitWithError("Could not parse session ID from response.");
+    }
+    saveSession({
+      tokenId: token,
+      sessionId,
+      baseUrl: BASE_URL,
+      expiresAt: expiresAt ?? new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString()
+    });
+    yield* Console2.log(`Session created: ${sessionId}`);
+    yield* Console2.log(`Expires: ${expiresAt ?? "24 hours"}`);
+    yield* Console2.log(`
+You're ready to go. Try: alphamilk playbooks`);
+  })
+).pipe(Command.withDescription("Authenticate with your access token"));
+var sessionCommand = Command.make(
+  "session",
+  {},
+  () => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    yield* Console2.log(`Session ID: ${session.sessionId}`);
+    yield* Console2.log(`Token: ${session.tokenId.slice(0, 8)}...`);
+    yield* Console2.log(`Base URL: ${session.baseUrl}`);
+    yield* Console2.log(`Expires: ${session.expiresAt}`);
+  })
+).pipe(Command.withDescription("Show current session info"));
+var playbooksCommand = Command.make(
+  "playbooks",
+  {},
+  () => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    const response = yield* apiGet(
+      session.baseUrl,
+      `/milk/playbook/${session.sessionId}`
+    ).pipe(handleApiError("Failed to list playbooks"));
+    yield* Console2.log(response);
+  })
+).pipe(Command.withDescription("List available research playbooks"));
+var playbookSlug = Args.text({ name: "slug" }).pipe(
+  Args.withDescription("Playbook slug (e.g., competitor-discovery)")
+);
+var playbookReport = Options.boolean("report").pipe(
+  Options.withAlias("r"),
+  Options.withDefault(false),
+  Options.withDescription("Get the report template instead of playbook content")
+);
+var playbookCommand = Command.make(
+  "playbook",
+  { slug: playbookSlug, report: playbookReport },
+  ({ slug, report }) => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    const urlPath = report ? `/milk/playbook/${session.sessionId}/${slug}/report` : `/milk/playbook/${session.sessionId}/${slug}`;
+    const response = yield* apiGet(session.baseUrl, urlPath).pipe(
+      handleApiError("Failed to get playbook")
+    );
+    yield* Console2.log(response);
+  })
+).pipe(Command.withDescription("Open a playbook or its report template"));
+var skillSlug = Args.text({ name: "slug" }).pipe(
+  Args.withDescription("Skill slug (e.g., serp-google, ranked-keywords)")
+);
+var skillParams = Options.keyValueMap("param").pipe(
+  Options.withAlias("p"),
+  Options.withDescription("Skill parameters as key=value pairs (repeat for multiple)"),
+  Options.optional
+);
+var skillCommand = Command.make(
+  "skill",
+  { slug: skillSlug, params: skillParams },
+  ({ slug, params }) => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    const queryParams = {};
+    if (params._tag === "Some") {
+      for (const [k, v] of params.value) {
+        queryParams[k] = v;
+      }
+    }
+    const response = yield* apiGet(
+      session.baseUrl,
+      `/milk/skill/${session.sessionId}/${slug}`,
+      queryParams
+    ).pipe(handleApiError("Skill execution failed"));
+    yield* Console2.log(response);
+  })
+).pipe(Command.withDescription("Execute a research skill"));
+var reportSaveName = Options.text("name").pipe(
+  Options.withAlias("n"),
+  Options.withDescription("Report title/name")
+);
+var reportSaveContent = Options.text("content").pipe(
+  Options.withAlias("c"),
+  Options.withDescription("Full markdown report content (inline). Use --file instead for file-based input."),
+  Options.optional
+);
+var reportSaveFile = Options.text("file").pipe(
+  Options.withAlias("f"),
+  Options.withDescription("Path to a markdown file containing the report content"),
+  Options.optional
+);
+var reportSaveCommand = Command.make(
+  "save",
+  { name: reportSaveName, content: reportSaveContent, file: reportSaveFile },
+  ({ name, content, file }) => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    let resolvedContent;
+    if (content._tag === "Some" && file._tag === "Some") {
+      return yield* exitWithError(
+        'Cannot use both --content and --file. Provide one or the other.\n\n  --file report.md      Read content from a markdown file\n  --content "# ..."     Pass content inline as a string'
+      );
+    }
+    if (content._tag === "None" && file._tag === "None") {
+      return yield* exitWithError(
+        'Missing report content. Provide one of:\n\n  --file report.md      Read content from a markdown file (recommended)\n  --content "# ..."     Pass content inline as a string\n\nExample:\n  alphamilk report save --name "My Report" --file ./report.md'
+      );
+    }
+    if (file._tag === "Some") {
+      resolvedContent = yield* readReportFile(file.value);
+    } else {
+      resolvedContent = content.value;
+    }
+    const response = yield* apiPost(
+      session.baseUrl,
+      `/milk/report/${session.sessionId}`,
+      { name, content: resolvedContent }
+    ).pipe(handleApiError("Failed to save report"));
+    yield* Console2.log(response);
+  })
+).pipe(Command.withDescription("Save a research report"));
+var reportGetId = Args.text({ name: "reportId" }).pipe(
+  Args.withDescription("Report ID")
+);
+var reportGetCommand = Command.make(
+  "get",
+  { reportId: reportGetId },
+  ({ reportId }) => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    const response = yield* apiGet(
+      session.baseUrl,
+      `/milk/report/${session.sessionId}/${reportId}`
+    ).pipe(handleApiError("Failed to get report"));
+    yield* Console2.log(response);
+  })
+).pipe(Command.withDescription("Retrieve a saved report"));
+var reportCommand = Command.make("report").pipe(
+  Command.withDescription("Save and retrieve research reports"),
+  Command.withSubcommands([reportSaveCommand, reportGetCommand])
+);
+var artifactSaveType = Options.choice("type", ["domains", "keywords"]).pipe(
+  Options.withDescription("Artifact type")
+);
+var artifactSaveTags = Options.text("tags").pipe(
+  Options.withDescription("Comma-separated tags (e.g., competitors,direct)")
+);
+var artifactSaveData = Options.text("data").pipe(
+  Options.withAlias("d"),
+  Options.withDescription("Comma-separated data items (e.g., example.com,other.com)")
+);
+var artifactSaveCommand = Command.make(
+  "save",
+  { type: artifactSaveType, tags: artifactSaveTags, data: artifactSaveData },
+  ({ type, tags, data }) => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    const response = yield* apiPost(
+      session.baseUrl,
+      `/milk/artifact/${session.sessionId}`,
+      {
+        type,
+        tags: tags.split(",").map((t) => t.trim()),
+        data: data.split(",").map((d) => d.trim())
+      }
+    ).pipe(handleApiError("Failed to save artifact"));
+    yield* Console2.log(response);
+  })
+).pipe(Command.withDescription("Save a research artifact"));
+var artifactGetId = Args.text({ name: "artifactId" }).pipe(
+  Args.withDescription("Artifact ID")
+);
+var artifactGetCommand = Command.make(
+  "get",
+  { artifactId: artifactGetId },
+  ({ artifactId }) => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    const response = yield* apiGet(
+      session.baseUrl,
+      `/milk/artifact/${session.sessionId}/${artifactId}`
+    ).pipe(handleApiError("Failed to get artifact"));
+    yield* Console2.log(response);
+  })
+).pipe(Command.withDescription("Retrieve a saved artifact"));
+var artifactListType = Options.text("type").pipe(
+  Options.withDescription("Filter by artifact type"),
+  Options.optional
+);
+var artifactListTag = Options.text("tag").pipe(
+  Options.withDescription("Filter by tag"),
+  Options.optional
+);
+var artifactListCommand = Command.make(
+  "list",
+  { type: artifactListType, tag: artifactListTag },
+  ({ type, tag }) => Effect3.gen(function* () {
+    const session = yield* requireSession;
+    const params = {};
+    if (type._tag === "Some") params.type = type.value;
+    if (tag._tag === "Some") params.tag = tag.value;
+    const response = yield* apiGet(
+      session.baseUrl,
+      `/milk/artifact/${session.sessionId}`,
+      params
+    ).pipe(handleApiError("Failed to list artifacts"));
+    yield* Console2.log(response);
+  })
+).pipe(Command.withDescription("List saved artifacts"));
+var artifactCommand = Command.make("artifact").pipe(
+  Command.withDescription("Save and retrieve research artifacts"),
+  Command.withSubcommands([artifactSaveCommand, artifactGetCommand, artifactListCommand])
+);
+var logoutCommand = Command.make(
+  "logout",
+  {},
+  () => Effect3.gen(function* () {
+    clearSession();
+    yield* Console2.log("Session cleared.");
+  })
+).pipe(Command.withDescription("Clear your session"));
+var root = Command.make("alphamilk").pipe(
+  Command.withDescription("AI-powered SEO research from your terminal"),
+  Command.withSubcommands([
+    loginCommand,
+    logoutCommand,
+    sessionCommand,
+    playbooksCommand,
+    playbookCommand,
+    skillCommand,
+    reportCommand,
+    artifactCommand
+  ])
+);
+var cli = Command.run(root, {
+  name: "alphamilk",
+  version: "0.0.1"
+});
+var MainLayer = Layer.mergeAll(
+  NodeContext.layer,
+  FetchHttpClient.layer
+);
+Effect3.suspend(() => cli(process.argv)).pipe(
+  Effect3.provide(MainLayer),
+  Logger.withMinimumLogLevel(LogLevel.None),
+  NodeRuntime.runMain({ disableErrorReporting: true })
+);

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "alphamilk",
+  "version": "0.0.1",
+  "type": "module",
+  "license": "MIT",
+  "description": "Alpha Milk CLI - AI-powered SEO research from your terminal",
+  "bin": {
+    "alphamilk": "dist/cli.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "dev": "npx tsx src/cli.ts",
+    "build": "node build.mjs",
+    "prepublishOnly": "rm -rf dist && node build.mjs",
+    "check": "tsc --noEmit",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@effect/cli": "^0.73.2",
+    "@effect/platform": "^0.94.4",
+    "@effect/platform-node": "^0.104.1",
+    "effect": "^3.19.16"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "vitest": "^3.2.0",
+    "@effect/vitest": "latest"
+  }
+}