hoomanjs 1.0.0

package/src/core/tools/time.ts

@@ -0,0 +1,121 @@
+import { tool } from "@strands-agents/sdk";
+import type { JSONValue } from "@strands-agents/sdk";
+import { DateTime, IANAZone } from "luxon";
+import { z } from "zod";
+
+type TimeInfo = {
+  timezone: string;
+  datetime: string;
+  day_of_week: string;
+  is_dst: boolean;
+};
+
+function toJsonValue(value: unknown): JSONValue {
+  return JSON.parse(JSON.stringify(value)) as JSONValue;
+}
+
+function getLocalTimezone(): string {
+  const zone = DateTime.local().zoneName;
+  return IANAZone.isValidZone(zone) ? zone : "UTC";
+}
+
+function resolveTimezone(timezone?: string): string {
+  const zone = timezone?.trim() || getLocalTimezone();
+  if (!IANAZone.isValidZone(zone)) {
+    throw new Error(`Invalid timezone: ${zone}`);
+  }
+  return zone;
+}
+
+function toTimeInfo(dt: DateTime): TimeInfo {
+  return {
+    timezone: dt.zoneName ?? "UTC",
+    datetime: dt.toISO({ suppressMilliseconds: true }) ?? dt.toISO() ?? "",
+    day_of_week: dt.weekdayLong ?? "",
+    is_dst: dt.isInDST,
+  };
+}
+
+function parseSourceTime(sourceTimezone: string, time: string): DateTime {
+  const sourceNow = DateTime.now().setZone(sourceTimezone);
+  const parsed = DateTime.fromFormat(time.trim(), "HH:mm", {
+    zone: sourceTimezone,
+  });
+
+  if (!parsed.isValid) {
+    throw new Error("Invalid time format. Expected HH:MM [24-hour format]");
+  }
+
+  return sourceNow.set({
+    hour: parsed.hour,
+    minute: parsed.minute,
+    second: 0,
+    millisecond: 0,
+  });
+}
+
+function formatOffsetDifference(source: DateTime, target: DateTime): string {
+  const diffHours = (target.offset - source.offset) / 60;
+  const formatted = Number.isInteger(diffHours)
+    ? diffHours.toFixed(1)
+    : diffHours.toFixed(2).replace(/0+$/, "").replace(/\.$/, "");
+  return `${diffHours >= 0 ? "+" : ""}${formatted}h`;
+}
+
+export function createTimeTools() {
+  const localTimezone = getLocalTimezone();
+
+  return [
+    tool({
+      name: "get_current_time",
+      description:
+        "Get the current time in a specific timezone. Defaults to the local timezone when omitted.",
+      inputSchema: z.object({
+        timezone: z
+          .string()
+          .optional()
+          .describe(
+            `IANA timezone name (e.g. 'America/New_York', 'Europe/London'). Defaults to '${localTimezone}'.`,
+          ),
+      }),
+      callback: async (input) => {
+        const timezone = resolveTimezone(input.timezone);
+        const current = DateTime.now().setZone(timezone);
+
+        return toJsonValue(toTimeInfo(current));
+      },
+    }),
+    tool({
+      name: "convert_time",
+      description:
+        "Convert a time between timezones. Defaults omitted timezones to the local timezone.",
+      inputSchema: z.object({
+        source_timezone: z
+          .string()
+          .optional()
+          .describe(
+            `Source IANA timezone name. Defaults to '${localTimezone}'.`,
+          ),
+        time: z.string().describe("Time to convert in 24-hour format (HH:MM)."),
+        target_timezone: z
+          .string()
+          .optional()
+          .describe(
+            `Target IANA timezone name. Defaults to '${localTimezone}'.`,
+          ),
+      }),
+      callback: async (input) => {
+        const sourceTimezone = resolveTimezone(input.source_timezone);
+        const targetTimezone = resolveTimezone(input.target_timezone);
+        const source = parseSourceTime(sourceTimezone, input.time);
+        const target = source.setZone(targetTimezone);
+
+        return toJsonValue({
+          source: toTimeInfo(source),
+          target: toTimeInfo(target),
+          time_difference: formatOffsetDifference(source, target),
+        });
+      },
+    }),
+  ];
+}

package/src/core/utils/cwd-context.ts

@@ -0,0 +1,11 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+const storage = new AsyncLocalStorage<string>();
+
+export function runWithCwd<T>(cwd: string, fn: () => Promise<T>): Promise<T> {
+  return storage.run(cwd, fn);
+}
+
+export function getCwd(): string {
+  return storage.getStore() ?? process.cwd();
+}

package/src/core/utils/paths.ts

@@ -0,0 +1,28 @@
+import { homedir } from "os";
+import { join } from "path";
+
+const HOME_FOLDER_NAME = ".hooman";
+
+export const basePath = () => {
+  return join(homedir(), HOME_FOLDER_NAME);
+};
+
+export const configJsonPath = () => {
+  return join(basePath(), "config.json");
+};
+
+export const instructionsMdPath = () => {
+  return join(basePath(), "instructions.md");
+};
+
+export const mcpJsonPath = () => {
+  return join(basePath(), "mcp.json");
+};
+
+export const sessionsPath = () => {
+  return join(basePath(), "sessions");
+};
+
+export const skillsPath = () => {
+  return join(basePath(), "skills");
+};

package/src/exec/approvals.ts

@@ -0,0 +1,85 @@
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { BeforeToolCallEvent } from "@strands-agents/sdk";
+import type { Config } from "../core/config.ts";
+
+const INTERNAL_ALWAYS_ALLOWED = new Set(["strands_structured_output"]);
+const INPUT_PREVIEW_LIMIT = 1_024;
+
+type ApprovalDecision = "allow" | "reject" | "always";
+
+function inputPreview(input: unknown): string {
+  try {
+    const text = JSON.stringify(input, null, 2) ?? "null";
+    return text.length > INPUT_PREVIEW_LIMIT
+      ? `${text.slice(0, INPUT_PREVIEW_LIMIT)}\n... (truncated)`
+      : text;
+  } catch {
+    return String(input);
+  }
+}
+
+function canPromptForApproval(): boolean {
+  return Boolean(stdin.isTTY && stdout.isTTY);
+}
+
+async function promptForApproval(
+  event: BeforeToolCallEvent,
+): Promise<ApprovalDecision> {
+  const rl = createInterface({ input: stdin, output: stdout });
+  const description = event.tool?.description?.trim();
+  const preview = inputPreview(event.toolUse.input);
+  try {
+    stdout.write(`\nTool approval required\n`);
+    stdout.write(`Tool: ${event.toolUse.name}\n`);
+    if (description) {
+      stdout.write(`Description: ${description}\n`);
+    }
+    stdout.write(`Input:\n${preview}\n`);
+    stdout.write(`Options: [a]llow once, [r]eject, [A]lways allow\n`);
+    while (true) {
+      const answer = (await rl.question("> ")).trim();
+      if (answer === "a" || answer === "allow" || answer === "") {
+        return "allow";
+      }
+      if (answer === "r" || answer === "reject") {
+        return "reject";
+      }
+      if (answer === "A" || answer === "always") {
+        return "always";
+      }
+      stdout.write("Enter a, r, or A.\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+type BeforeToolCallEventHandler = (event: BeforeToolCallEvent) => Promise<void>;
+
+export function createToolApprovalHandler(
+  config: Config,
+): BeforeToolCallEventHandler {
+  return async function onBeforeToolCallEvent(event: BeforeToolCallEvent) {
+    const name = event.toolUse.name;
+    if (
+      INTERNAL_ALWAYS_ALLOWED.has(name) ||
+      config.tools.allowed.includes(name)
+    ) {
+      return;
+    }
+    if (!canPromptForApproval()) {
+      event.cancel = `Tool "${name}" requires approval, but no interactive terminal is available. Add it to config.tools.allowed to always allow it.`;
+      return;
+    }
+    const decision = await promptForApproval(event);
+    if (decision === "allow") {
+      return;
+    }
+    if (decision === "always") {
+      config.update({ tools: { allowed: [...config.tools.allowed, name] } });
+      return;
+    }
+    event.cancel = `Tool "${name}" was rejected by the user.`;
+  };
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "types": ["bun"],
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}