@globasoft/auto-goal-ai-generator

AI-powered goal generator. Give it a goal in plain language and it returns several distinct approaches for achieving it — each with its tradeoffs — using Claude.

Install

npm install @globasoft/auto-goal-ai-generator @anthropic-ai/sdk

@anthropic-ai/sdk is a peer dependency, so you install it alongside this package. Requires Node.js >= 22.

Usage

import Anthropic from "@anthropic-ai/sdk";
import { GoalGenerator } from "@globasoft/auto-goal-ai-generator";

const client = new Anthropic(); // reads ANTHROPIC_API_KEY from the environment
const generator = new GoalGenerator({ client });

const result = await generator.generate("learn Spanish in 6 months");

console.log(result.goal);    // "learn Spanish in 6 months"
console.log(result.options); // string[] of 3–5 distinct approaches with tradeoffs

Set your API key first:

export ANTHROPIC_API_KEY="sk-ant-..."   # PowerShell: $env:ANTHROPIC_API_KEY="sk-ant-..."

API

new GoalGenerator(options)

| Option | Type | Required | Description | | --------- | ----------- | -------- | ------------------------------------------------------- | | client | Anthropic | yes | An @anthropic-ai/sdk client instance. | | plugins | Plugin[] | no | Middleware applied around generation (see Plugins). |

generator.generate(goal: string): Promise<GoalResult>

Runs the (optional) plugin chain and the strategy, returning:

interface GoalResult {
  goal: string;
  options: string[];
}

By default it asks Claude for 3–5 meaningfully different approaches, each formatted as a description plus its tradeoffs.

generator.use(plugin: Plugin): this

Appends a plugin and returns the generator for chaining.

Plugins

Plugins are onion-style middleware — each receives the shared context and a next() function, and decides whether to call it:

type Plugin = (
  context: PluginContext,
  next: () => Promise<void>,
) => Promise<void>;

interface PluginContext {
  goal: string;
  result: GoalResult | null;
  strategy?: Strategy; // override the default Claude strategy
}

A plugin can:

• transform the goal before generation (mutate context.goal, then await next()),
• inspect or post-process the result (await next(), then read/modify context.result),
• short-circuit by setting context.result and not calling next(),
• swap the strategy entirely by setting context.strategy.

// Example: log timing and uppercase the goal before generating.
const timing: Plugin = async (ctx, next) => {
  ctx.goal = ctx.goal.trim();
  const start = performance.now();
  await next();
  console.log(`generated in ${Math.round(performance.now() - start)}ms`);
};

const generator = new GoalGenerator({ client }).use(timing);

Custom strategy

A Strategy produces the raw result. Provide one via a plugin to fully control the prompt or model:

import type { Strategy } from "@globasoft/auto-goal-ai-generator";

const myStrategy: Strategy = async (client, goal) => {
  // ...call client.messages.create(...) however you like
  return { goal, options: ["..."] };
};

generator.use(async (ctx, next) => {
  ctx.strategy = myStrategy;
  await next();
});

License

MIT © Globasoft