terry-core 0.1.2 → 1.0.0

package/dist/config.d.ts

@@ -4,6 +4,7 @@ export declare function workspacesFile(): string;
 export declare function auditLogFile(): string;
 export declare function usageDir(): string;
 export declare function cloudSyncConfigFile(): string;
+export declare function memoryFile(): string;
 export declare function ensureTerryDirs(): Promise<void>;
 type WorkspaceMap = Record<string, WorkspaceSettings>;
 export declare function loadWorkspaceMap(): Promise<WorkspaceMap>;

package/dist/config.js

@@ -8,9 +8,19 @@ const DEFAULT_TOOLS = {
     readFile: "enabled",
     writeFile: "enabled",
     searchInFiles: "enabled",
+    webSearch: "enabled",
     gitStatus: "enabled",
     gitDiff: "enabled",
-    runCommand: "enabled"
+    runCommand: "enabled",
+    memorySet: "enabled",
+    memoryGet: "enabled",
+    openCalendarEvent: "ask",
+    openGitHubIssue: "ask",
+    openNotionPage: "ask",
+    openLinearIssue: "ask",
+    openSlackCompose: "ask",
+    openEmail: "ask",
+    openMapsDirections: "ask"
 };
 export function terryHomeDir() {
     return path.join(os.homedir(), ".terry");
@@ -27,6 +37,9 @@ export function usageDir() {
 export function cloudSyncConfigFile() {
     return path.join(terryHomeDir(), "cloud-sync.json");
 }
+export function memoryFile() {
+    return path.join(terryHomeDir(), "memory.json");
+}
 export async function ensureTerryDirs() {
     await fs.mkdir(terryHomeDir(), { recursive: true });
     await fs.mkdir(usageDir(), { recursive: true });
@@ -85,6 +98,14 @@ export async function getWorkspaceSettings(workspacePath) {
             await saveWorkspaceMap(map);
         }
     }
+    const mergedTools = { ...DEFAULT_TOOLS, ...(map[key].tools ?? {}) };
+    if (JSON.stringify(mergedTools) !== JSON.stringify(map[key].tools ?? {})) {
+        map[key] = {
+            ...map[key],
+            tools: mergedTools
+        };
+        await saveWorkspaceMap(map);
+    }
     return map[key];
 }
 export async function setWorkspaceSettings(workspacePath, patch) {

package/dist/orchestrator.js

@@ -1,12 +1,259 @@
+const KNOWN_COMMANDS = ["git", "npm", "pnpm", "yarn", "node", "npx"];
 const TOOL_HINTS = [
-    { tool: "writeFile", match: /\b(write|create|update|edit|save)\b.*\b(file|doc|readme|json|ts|js)\b/i },
-    { tool: "readFile", match: /\b(read|open|show)\b.*\b(file|md|json|ts|js|readme)\b/i },
+    { tool: "webSearch", match: /\b(web search|search web|lookup online|latest on|news on|current events?)\b/i },
+    { tool: "memorySet", match: /\bremember(?:\s+that)?\b/i },
+    { tool: "memoryGet", match: /\b(what do you remember|what did i tell you|recall|remember my|what is my)\b/i },
+    { tool: "openCalendarEvent", match: /\b(schedule|calendar|meeting|event)\b/i },
+    { tool: "openGitHubIssue", match: /\b(github issue|create issue|open issue)\b/i },
+    { tool: "openNotionPage", match: /\bnotion\b.*\b(page|note)\b|\bcreate notion\b/i },
+    { tool: "openLinearIssue", match: /\b(linear|jira)\b.*\b(issue|ticket)\b/i },
+    { tool: "openSlackCompose", match: /\bslack\b.*\b(message|send|compose)\b/i },
+    { tool: "openEmail", match: /\b(draft an email|send an email|mailto|email)\b/i },
+    { tool: "openMapsDirections", match: /\b(directions?|navigate|maps?)\b/i },
+    { tool: "runCommand", match: /\b(run|execute)\b|\b(git|npm|pnpm|yarn|node|npx)\b/i },
+    { tool: "writeFile", match: /\b(write|create|update|edit|save)\b.*\b(file|readme|json|md|ts|js)\b/i },
+    { tool: "readFile", match: /\b(read|open|show)\b.*\b(file|readme|json|md|ts|js)\b/i },
     { tool: "searchInFiles", match: /\b(search|find|grep|look for)\b/i },
     { tool: "gitStatus", match: /\bgit status|repo status|what changed\b/i },
     { tool: "gitDiff", match: /\bgit diff|show diff|changes\b/i },
-    { tool: "runCommand", match: /\b(run|execute|command|npm|pnpm|yarn|test|build)\b/i },
     { tool: "listDirectory", match: /\b(list|ls|folders?|directories?)\b/i }
 ];
+function stripWrappers(value) {
+    return value.trim().replace(/^["'`]|["'`]$/g, "");
+}
+function tokenizeCommand(raw) {
+    const tokens = [];
+    let current = "";
+    let quote = "";
+    for (let i = 0; i < raw.length; i += 1) {
+        const ch = raw[i];
+        if (!ch)
+            continue;
+        if (quote) {
+            if (ch === quote) {
+                quote = "";
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+function extractFirstPath(content) {
+    const quoted = content.match(/["'`]([^"'`]+)["'`]/);
+    if (quoted?.[1])
+        return quoted[1].trim();
+    const direct = content.match(/\b([./\\]?[a-zA-Z0-9_\-/\\.]+\.[a-zA-Z0-9_]+)\b/);
+    if (direct?.[1])
+        return direct[1].trim();
+    return null;
+}
+function extractQuoted(content) {
+    return content.match(/["'`]([^"'`]+)["'`]/)?.[1]?.trim() ?? null;
+}
+function extractEmails(content) {
+    return [...content.matchAll(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi)].map((match) => match[0]);
+}
+function parseTime(content) {
+    const match = content.match(/\b(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\b/i);
+    if (!match?.[1])
+        return null;
+    let hour = Number(match[1]);
+    const minute = Number(match[2] ?? "0");
+    const meridiem = (match[3] ?? "").toLowerCase();
+    if (meridiem === "pm" && hour < 12)
+        hour += 12;
+    if (meridiem === "am" && hour === 12)
+        hour = 0;
+    if (Number.isNaN(hour) || Number.isNaN(minute))
+        return null;
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+        return null;
+    return { hour, minute };
+}
+function parseDatePhrase(content) {
+    const lower = content.toLowerCase();
+    const now = new Date();
+    const explicitDate = content.match(/\b(\d{4}-\d{2}-\d{2})(?:[ t](\d{1,2}):(\d{2}))?/);
+    if (explicitDate?.[1]) {
+        const base = new Date(`${explicitDate[1]}T00:00:00`);
+        const hh = Number(explicitDate[2] ?? "9");
+        const mm = Number(explicitDate[3] ?? "0");
+        base.setHours(hh, mm, 0, 0);
+        return base;
+    }
+    const parsedTime = parseTime(content) ?? { hour: 9, minute: 0 };
+    const base = new Date();
+    if (lower.includes("tomorrow")) {
+        base.setDate(base.getDate() + 1);
+    }
+    else if (lower.includes("today")) {
+        // keep today
+    }
+    else {
+        const parsed = Date.parse(content);
+        if (!Number.isNaN(parsed))
+            return new Date(parsed);
+        base.setDate(now.getDate() + 1);
+    }
+    base.setHours(parsedTime.hour, parsedTime.minute, 0, 0);
+    return base;
+}
+function parseRunCommand(content) {
+    const backtick = content.match(/`([^`]+)`/);
+    const candidate = backtick?.[1] ??
+        content.match(/\b(?:run|execute)(?:\s+the)?(?:\s+command)?\s+(.+)$/i)?.[1] ??
+        content.match(new RegExp(`^\\s*(${KNOWN_COMMANDS.join("|")})\\b(.+)?$`, "i"))?.[0] ??
+        "";
+    const normalized = candidate.trim().replace(/[.;,\s]+$/g, "");
+    if (!normalized)
+        return null;
+    const tokens = tokenizeCommand(normalized);
+    if (tokens.length === 0)
+        return null;
+    const [cmd, ...args] = tokens;
+    if (!cmd || !KNOWN_COMMANDS.includes(cmd.toLowerCase())) {
+        return null;
+    }
+    return { cmd, args };
+}
+function parseReadFileArgs(content) {
+    const pathMatch = content.match(/\b(?:read|open|show)(?:\s+the)?(?:\s+file)?\s+["'`]([^"'`]+)["'`]/i)?.[1] ??
+        extractFirstPath(content);
+    return { pathRelativeToWorkspace: pathMatch ?? "README.md" };
+}
+function parseWriteFileArgs(content) {
+    const pathMatch = content.match(/\b(?:write|create|update|edit|save)(?:\s+(?:to|into))?(?:\s+file)?\s+["'`]([^"'`]+)["'`]/i)?.[1] ??
+        content.match(/\b(?:write|create|update|edit|save)(?:\s+(?:to|into))?(?:\s+file)?\s+([^\s]+)\b/i)?.[1] ??
+        extractFirstPath(content) ??
+        "README.md";
+    const contentMatch = content.match(/\b(?:with content|with text|saying|that says)\s+([\s\S]+)$/i)?.[1] ??
+        content.match(/:\s*([\s\S]+)$/)?.[1] ??
+        `# Terry update\n\nGenerated from task:\n${content}\n`;
+    return {
+        pathRelativeToWorkspace: stripWrappers(pathMatch),
+        content: contentMatch.trim()
+    };
+}
+function parseSearchArgs(content) {
+    const quoted = content.match(/["'`]([^"'`]+)["'`]/)?.[1];
+    const phrase = quoted ??
+        content.match(/\b(?:search|find|grep|look for)\b\s+([\s\S]+)$/i)?.[1] ??
+        content;
+    return { query: phrase.replace(/^for\s+/i, "").trim() };
+}
+function parseWebSearchArgs(content) {
+    const quoted = extractQuoted(content);
+    const phrase = quoted ??
+        content
+            .replace(/\b(web search|search web|lookup online|latest on|news on|current events?)\b/gi, "")
+            .replace(/^for\s+/i, "")
+            .trim();
+    return { query: phrase || content.trim(), maxResults: 5 };
+}
+function parseListDirectoryArgs(content) {
+    const target = content.match(/\b(?:in|inside|under)\s+["'`]([^"'`]+)["'`]/i)?.[1] ??
+        content.match(/\b(?:in|inside|under)\s+([^\s]+)\b/i)?.[1] ??
+        ".";
+    return { pathRelativeToWorkspace: stripWrappers(target) || "." };
+}
+function parseMemorySetArgs(content) {
+    const remember = content.match(/\bremember(?:\s+that)?\s+(.+?)\s+(?:is|=|as)\s+([\s\S]+)$/i) ??
+        content.match(/\bremember(?:\s+that)?\s+(.+?)\s*:\s*([\s\S]+)$/i);
+    if (remember?.[1] && remember?.[2]) {
+        return { key: remember[1].trim(), value: remember[2].trim() };
+    }
+    const fallback = content.replace(/\bremember(?:\s+that)?\s*/i, "").trim();
+    return { key: "note", value: fallback || content };
+}
+function parseMemoryGetArgs(content) {
+    const parsed = content.match(/\b(?:what(?:'s| is)\s+(?:my|the)\s+|recall\s+|remember\s+)([\w\s._/-]+)\??$/i)?.[1] ??
+        content.replace(/\?+$/, "");
+    return { key: parsed.trim() || "note" };
+}
+function parseCalendarArgs(content) {
+    const quoted = extractQuoted(content);
+    const title = quoted ??
+        content.match(/\bcalled\s+([^.,]+?)(?:\s+(?:with|tomorrow|today|at|on)\b|$)/i)?.[1]?.trim() ??
+        "Terry Meeting";
+    const start = parseDatePhrase(content);
+    const end = new Date(start.getTime() + 60 * 60 * 1000);
+    const attendees = extractEmails(content);
+    return {
+        title,
+        startIso: start.toISOString(),
+        endIso: end.toISOString(),
+        attendees: attendees.length ? attendees : undefined
+    };
+}
+function parseGitHubIssueArgs(content) {
+    const title = extractQuoted(content) ??
+        content.match(/\b(?:issue|ticket)\s*:\s*(.+?)(?=\s+\bwith\s+labels?\b|\s+\bwith\s+label\b|\s+\b(?:in|for)\s+[a-z0-9_.-]+\/[a-z0-9_.-]+|$)/i)?.[1]?.trim() ??
+        content.match(/\b(?:issue|ticket)\s+(.+?)(?=\s+\bwith\s+labels?\b|\s+\bwith\s+label\b|\s+\b(?:in|for)\s+[a-z0-9_.-]+\/[a-z0-9_.-]+|$)/i)?.[1]?.trim() ??
+        "New issue";
+    const labelsRaw = content.match(/\blabels?\s+(.+?)(?=\s+\b(?:in|for)\s+[a-z0-9_.-]+\/[a-z0-9_.-]+\b|$)/i)?.[1];
+    const repo = content.match(/\b(?:in|for)\s+([a-z0-9_.-]+\/[a-z0-9_.-]+)\b/i)?.[1];
+    return {
+        title,
+        labels: labelsRaw
+            ? labelsRaw
+                .split(/[,\s]+/)
+                .map((label) => label.trim())
+                .filter(Boolean)
+            : undefined,
+        repo
+    };
+}
+function parseNotionArgs(content) {
+    const title = extractQuoted(content) ??
+        content.match(/\b(?:called|named|title)\s+([^.,]+)$/i)?.[1]?.trim() ??
+        "New Terry Note";
+    return { title };
+}
+function parseLinearArgs(content) {
+    const title = extractQuoted(content) ??
+        content.match(/\b(?:ticket|issue)\s*:\s*(.+?)(?=\s+\b(?:in|for)\s+project\b|$)/i)?.[1]?.trim() ??
+        content.match(/\b(?:ticket|issue)\s+(.+?)(?=\s+\b(?:in|for)\s+project\b|$)/i)?.[1]?.trim() ??
+        "New ticket";
+    const project = content.match(/\bproject\s+([a-z0-9_-]+)\b/i)?.[1];
+    return { title, project };
+}
+function parseSlackArgs(content) {
+    const channel = content.match(/#([a-z0-9_-]+)/i)?.[1];
+    const quoted = extractQuoted(content);
+    const afterColon = content.match(/:\s*([\s\S]+)$/)?.[1]?.trim();
+    const message = quoted ?? afterColon ?? "Update from Terry";
+    return { channel, message };
+}
+function parseEmailArgs(content) {
+    const to = extractEmails(content)[0];
+    const subject = content.match(/\bsubject\s+["'`]([^"'`]+)["'`]/i)?.[1] ??
+        content.match(/\babout\s+([^.,]+)$/i)?.[1]?.trim() ??
+        "Terry note";
+    const body = extractQuoted(content) ?? content.match(/:\s*([\s\S]+)$/)?.[1]?.trim() ?? undefined;
+    return { to, subject, body };
+}
+function parseDirectionsArgs(content) {
+    const destination = content.match(/\b(?:to|for)\s+([^.,]+)$/i)?.[1]?.trim() ?? extractQuoted(content) ?? content;
+    const provider = /\bapple maps?\b/i.test(content) ? "apple" : "google";
+    return { destination, provider };
+}
 function inferTool(content) {
     for (const hint of TOOL_HINTS) {
         if (hint.match.test(content))
@@ -15,27 +262,42 @@ function inferTool(content) {
     return null;
 }
 function inferArgs(tool, content) {
-    if (tool === "searchInFiles") {
-        const phrase = content.split("search").pop()?.trim() || content;
-        return { query: phrase.replace(/^for\s+/i, "") };
-    }
-    if (tool === "runCommand") {
-        return { cmd: "echo", args: [content] };
-    }
+    if (tool === "searchInFiles")
+        return parseSearchArgs(content);
+    if (tool === "webSearch")
+        return parseWebSearchArgs(content);
+    if (tool === "runCommand")
+        return parseRunCommand(content);
     if (tool === "listDirectory")
-        return { pathRelativeToWorkspace: "." };
+        return parseListDirectoryArgs(content);
     if (tool === "gitStatus")
         return {};
-    if (tool === "gitDiff")
-        return {};
-    if (tool === "readFile")
-        return { pathRelativeToWorkspace: "README.md" };
-    if (tool === "writeFile") {
-        return {
-            pathRelativeToWorkspace: "README.md",
-            content: `# Terry update\n\nGenerated from task:\n${content}\n`
-        };
+    if (tool === "gitDiff") {
+        const target = extractFirstPath(content);
+        return target ? { path: target } : {};
     }
+    if (tool === "readFile")
+        return parseReadFileArgs(content);
+    if (tool === "writeFile")
+        return parseWriteFileArgs(content);
+    if (tool === "memorySet")
+        return parseMemorySetArgs(content);
+    if (tool === "memoryGet")
+        return parseMemoryGetArgs(content);
+    if (tool === "openCalendarEvent")
+        return parseCalendarArgs(content);
+    if (tool === "openGitHubIssue")
+        return parseGitHubIssueArgs(content);
+    if (tool === "openNotionPage")
+        return parseNotionArgs(content);
+    if (tool === "openLinearIssue")
+        return parseLinearArgs(content);
+    if (tool === "openSlackCompose")
+        return parseSlackArgs(content);
+    if (tool === "openEmail")
+        return parseEmailArgs(content);
+    if (tool === "openMapsDirections")
+        return parseDirectionsArgs(content);
     return {};
 }
 export const rulesOrchestrator = (messages) => {
@@ -46,13 +308,20 @@ export const rulesOrchestrator = (messages) => {
     if (!tool) {
         return {
             kind: "summarize",
-            summary: "I can help with workspace files, search, git, and command planning. Ask a concrete repo or file operation."
+            summary: "I can help with workspace files, search, git, memory, and assistant actions like calendar/email/deep-links."
+        };
+    }
+    const args = inferArgs(tool, lastUser.content);
+    if (tool === "runCommand" && !args) {
+        return {
+            kind: "summarize",
+            summary: "I can run approved workspace commands. Please provide an explicit command, for example: run `npm test`."
         };
     }
     return {
         kind: "ask_permission",
         tool,
-        args: inferArgs(tool, lastUser.content),
+        args,
         reason: `Detected request likely needs tool: ${tool}.`
     };
 };

package/dist/permissions.js

@@ -20,5 +20,14 @@ export function toolRiskLevel(tool) {
         return "high";
     if (tool === "writeFile")
         return "medium";
+    if (tool === "openCalendarEvent" ||
+        tool === "openGitHubIssue" ||
+        tool === "openNotionPage" ||
+        tool === "openLinearIssue" ||
+        tool === "openSlackCompose" ||
+        tool === "openEmail" ||
+        tool === "openMapsDirections") {
+        return "medium";
+    }
     return "low";
 }

package/dist/policy.js

@@ -1,4 +1,12 @@
-const READ_ONLY_TOOLS = ["listDirectory", "readFile", "searchInFiles", "gitStatus", "gitDiff"];
+const READ_ONLY_TOOLS = [
+    "listDirectory",
+    "readFile",
+    "searchInFiles",
+    "webSearch",
+    "gitStatus",
+    "gitDiff",
+    "memoryGet"
+];
 const COMMAND_ALLOWLIST = new Set(["git", "npm", "pnpm", "yarn", "node", "npx"]);
 export function isReadOnlyTool(tool) {
     return READ_ONLY_TOOLS.includes(tool);

package/dist/tools.d.ts

@@ -2,6 +2,17 @@ import type { ToolArgsMap, ToolName, ToolResult, WorkspaceSettings } from "./typ
 type ToolContext = {
     workspacePath: string;
     settings: WorkspaceSettings;
+    cloud?: {
+        webSearch?: (query: string, maxResults?: number) => Promise<{
+            query: string;
+            provider: string;
+            results: Array<{
+                title: string;
+                url: string;
+                snippet: string;
+            }>;
+        }>;
+    };
 };
 export declare function executeTool<T extends ToolName>(context: ToolContext, tool: T, args: ToolArgsMap[T]): Promise<ToolResult>;
 export {};

package/dist/tools.js

@@ -6,10 +6,110 @@ import fg from "fast-glob";
 import { resolveInWorkspace } from "./sandbox.js";
 import { appendAudit } from "./audit.js";
 import { applyPatchProposal, createPatchProposal } from "./patches.js";
+import { memoryFile } from "./config.js";
 const execFileAsync = promisify(execFile);
 function dryRunResult(tool, files = []) {
     return { ok: true, output: `[dry-run] ${tool} skipped execution.`, files };
 }
+function normalizeMemoryKey(key) {
+    return key.trim().toLowerCase();
+}
+async function loadMemoryStore() {
+    try {
+        const raw = await fs.readFile(memoryFile(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+async function saveMemoryStore(store) {
+    await fs.mkdir(path.dirname(memoryFile()), { recursive: true });
+    await fs.writeFile(memoryFile(), JSON.stringify(store, null, 2), "utf8");
+}
+function formatCalendarDate(date) {
+    return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function toCalendarRange(startIso, endIso) {
+    const start = Number.isNaN(Date.parse(startIso)) ? new Date() : new Date(startIso);
+    const end = endIso && !Number.isNaN(Date.parse(endIso))
+        ? new Date(endIso)
+        : new Date(start.getTime() + 60 * 60 * 1000);
+    if (end.getTime() <= start.getTime()) {
+        end.setTime(start.getTime() + 60 * 60 * 1000);
+    }
+    return `${formatCalendarDate(start)}/${formatCalendarDate(end)}`;
+}
+function buildCalendarUrl(args) {
+    const params = new URLSearchParams({
+        action: "TEMPLATE",
+        text: args.title,
+        dates: toCalendarRange(args.startIso, args.endIso)
+    });
+    if (args.attendees?.length) {
+        params.set("add", args.attendees.join(","));
+    }
+    return `https://calendar.google.com/calendar/render?${params.toString()}`;
+}
+function buildGitHubIssueUrl(args) {
+    const base = args.repo ? `https://github.com/${args.repo}/issues/new` : "https://github.com/issues/new";
+    const params = new URLSearchParams({ title: args.title });
+    if (args.body)
+        params.set("body", args.body);
+    if (args.labels?.length)
+        params.set("labels", args.labels.join(","));
+    return `${base}?${params.toString()}`;
+}
+function buildNotionUrl(args) {
+    const params = new URLSearchParams({ title: args.title });
+    return `https://www.notion.so/new?${params.toString()}`;
+}
+function buildLinearUrl(args) {
+    const params = new URLSearchParams({ title: args.title });
+    if (args.description)
+        params.set("description", args.description);
+    if (args.project)
+        params.set("project", args.project);
+    return `https://linear.app/new?${params.toString()}`;
+}
+function buildSlackUrl(args) {
+    const params = new URLSearchParams();
+    if (args.channel)
+        params.set("id", args.channel);
+    params.set("message", args.message);
+    return `slack://channel?${params.toString()}`;
+}
+function buildMailtoUrl(args) {
+    const recipient = args.to ?? "";
+    const params = new URLSearchParams();
+    if (args.subject)
+        params.set("subject", args.subject);
+    if (args.body)
+        params.set("body", args.body);
+    const query = params.toString();
+    return query ? `mailto:${encodeURIComponent(recipient)}?${query}` : `mailto:${encodeURIComponent(recipient)}`;
+}
+function buildMapsUrl(args) {
+    if (args.provider === "apple") {
+        return `https://maps.apple.com/?daddr=${encodeURIComponent(args.destination)}`;
+    }
+    return `https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(args.destination)}`;
+}
+async function openExternalUrl(url) {
+    if (process.platform === "win32") {
+        const escaped = url.replace(/'/g, "''");
+        await execFileAsync("powershell.exe", ["-NoProfile", "-Command", `Start-Process '${escaped}'`]);
+        return;
+    }
+    if (process.platform === "darwin") {
+        await execFileAsync("open", [url]);
+        return;
+    }
+    await execFileAsync("xdg-open", [url]);
+}
 async function withAudit(context, tool, args, affectedFiles, runner) {
     try {
         const result = await runner();
@@ -114,6 +214,29 @@ export async function executeTool(context, tool, args) {
                 }
                 return { ok: true, output: hits.join("\n") || "No matches.", files: hits };
             });
+        case "webSearch":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const query = parsed.query?.trim();
+                if (!query)
+                    return { ok: false, error: "Search query is required." };
+                if (context.settings.dryRun)
+                    return { ok: true, output: `[dry-run] would search web for: ${query}` };
+                if (!context.cloud?.webSearch) {
+                    return { ok: false, error: "webSearch requires cloud relay integration." };
+                }
+                const payload = await context.cloud.webSearch(query, parsed.maxResults);
+                const lines = payload.results.map((item, index) => {
+                    const title = item.title?.trim() || "Untitled";
+                    const snippet = item.snippet?.trim() || "No snippet.";
+                    const url = item.url?.trim() || "";
+                    return `${index + 1}. ${title}\n   ${snippet}\n   ${url}`;
+                });
+                return {
+                    ok: true,
+                    output: [`Provider: ${payload.provider}`, `Query: ${payload.query}`, "", ...lines].join("\n")
+                };
+            });
         case "gitStatus":
             return withAudit(context, tool, args, [], async () => {
                 if (context.settings.dryRun)
@@ -142,6 +265,97 @@ export async function executeTool(context, tool, args) {
                 const { stdout, stderr } = await execFileAsync(parsed.cmd, parsed.args ?? [], { cwd });
                 return { ok: true, output: `${stdout}${stderr}`.trim() };
             });
+        case "memorySet":
+            return withAudit(context, tool, args, [memoryFile()], async () => {
+                const parsed = args;
+                const key = normalizeMemoryKey(parsed.key);
+                if (!key)
+                    return { ok: false, error: "Memory key is required." };
+                if (context.settings.dryRun)
+                    return dryRunResult(tool, [memoryFile()]);
+                const store = await loadMemoryStore();
+                store[key] = parsed.value;
+                await saveMemoryStore(store);
+                return { ok: true, output: `Saved memory key "${key}".`, files: [memoryFile()] };
+            });
+        case "memoryGet":
+            return withAudit(context, tool, args, [memoryFile()], async () => {
+                const parsed = args;
+                const key = normalizeMemoryKey(parsed.key);
+                if (!key)
+                    return { ok: false, error: "Memory key is required." };
+                if (context.settings.dryRun)
+                    return dryRunResult(tool, [memoryFile()]);
+                const store = await loadMemoryStore();
+                const value = store[key];
+                if (!value) {
+                    return { ok: true, output: `No memory found for "${key}".`, files: [memoryFile()] };
+                }
+                return { ok: true, output: value, files: [memoryFile()] };
+            });
+        case "openCalendarEvent":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const url = buildCalendarUrl(parsed);
+                if (context.settings.dryRun)
+                    return { ok: true, output: `[dry-run] would open ${url}` };
+                await openExternalUrl(url);
+                return { ok: true, output: `Opened calendar event draft.\n${url}` };
+            });
+        case "openGitHubIssue":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const url = buildGitHubIssueUrl(parsed);
+                if (context.settings.dryRun)
+                    return { ok: true, output: `[dry-run] would open ${url}` };
+                await openExternalUrl(url);
+                return { ok: true, output: `Opened GitHub issue draft.\n${url}` };
+            });
+        case "openNotionPage":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const url = buildNotionUrl(parsed);
+                if (context.settings.dryRun)
+                    return { ok: true, output: `[dry-run] would open ${url}` };
+                await openExternalUrl(url);
+                return { ok: true, output: `Opened Notion page draft.\n${url}` };
+            });
+        case "openLinearIssue":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const url = buildLinearUrl(parsed);
+                if (context.settings.dryRun)
+                    return { ok: true, output: `[dry-run] would open ${url}` };
+                await openExternalUrl(url);
+                return { ok: true, output: `Opened Linear issue draft.\n${url}` };
+            });
+        case "openSlackCompose":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const url = buildSlackUrl(parsed);
+                if (context.settings.dryRun)
+                    return { ok: true, output: `[dry-run] would open ${url}` };
+                await openExternalUrl(url);
+                return { ok: true, output: `Opened Slack compose deep link.\n${url}` };
+            });
+        case "openEmail":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const url = buildMailtoUrl(parsed);
+                if (context.settings.dryRun)
+                    return { ok: true, output: `[dry-run] would open ${url}` };
+                await openExternalUrl(url);
+                return { ok: true, output: `Opened email draft.\n${url}` };
+            });
+        case "openMapsDirections":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const url = buildMapsUrl(parsed);
+                if (context.settings.dryRun)
+                    return { ok: true, output: `[dry-run] would open ${url}` };
+                await openExternalUrl(url);
+                return { ok: true, output: `Opened map directions.\n${url}` };
+            });
         default:
             return { ok: false, error: "Unknown tool." };
     }

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export type PermissionLevel = "disabled" | "enabled" | "ask";
 export type AgentMode = "general" | "focus" | "builder";
 export type ExecutionMode = "plan" | "safe" | "autonomous";
-export type ToolName = "listDirectory" | "readFile" | "writeFile" | "searchInFiles" | "gitStatus" | "gitDiff" | "runCommand";
+export type ToolName = "listDirectory" | "readFile" | "writeFile" | "searchInFiles" | "webSearch" | "gitStatus" | "gitDiff" | "runCommand" | "memorySet" | "memoryGet" | "openCalendarEvent" | "openGitHubIssue" | "openNotionPage" | "openLinearIssue" | "openSlackCompose" | "openEmail" | "openMapsDirections";
 export type ToolArgsMap = {
     listDirectory: {
         pathRelativeToWorkspace?: string;
@@ -16,6 +16,10 @@ export type ToolArgsMap = {
     searchInFiles: {
         query: string;
     };
+    webSearch: {
+        query: string;
+        maxResults?: number;
+    };
     gitStatus: Record<string, never>;
     gitDiff: {
         path?: string;
@@ -25,6 +29,46 @@ export type ToolArgsMap = {
         args?: string[];
         cwdRelativeToWorkspace?: string;
     };
+    memorySet: {
+        key: string;
+        value: string;
+    };
+    memoryGet: {
+        key: string;
+    };
+    openCalendarEvent: {
+        title: string;
+        startIso: string;
+        endIso?: string;
+        attendees?: string[];
+    };
+    openGitHubIssue: {
+        title: string;
+        body?: string;
+        labels?: string[];
+        repo?: string;
+    };
+    openNotionPage: {
+        title: string;
+    };
+    openLinearIssue: {
+        title: string;
+        description?: string;
+        project?: string;
+    };
+    openSlackCompose: {
+        channel?: string;
+        message: string;
+    };
+    openEmail: {
+        to?: string;
+        subject?: string;
+        body?: string;
+    };
+    openMapsDirections: {
+        destination: string;
+        provider?: "google" | "apple";
+    };
 };
 export type ToolResult = {
     ok: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terry-core",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "description": "Core policy, tooling, and orchestration modules for Terry Agent.",
   "license": "MIT",
   "author": "ELEVAREL",