agent-sin 0.1.0

package/dist/core/output-writer.js

@@ -0,0 +1,100 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { l } from "./i18n.js";
+export async function writeSkillOutputs(config, manifest, result, date = new Date()) {
+    const saved = [];
+    for (const output of manifest.outputs || []) {
+        const value = result.outputs?.[output.id];
+        if (!value) {
+            continue;
+        }
+        if (output.type !== "markdown") {
+            throw new Error(l(`Unsupported output type: ${output.type}`, `未対応の出力形式です: ${output.type}`));
+        }
+        const file = resolveOutputFile(config, output, date);
+        assertAllowedOutputPath(config, file);
+        await writeMarkdown(file, output, value, date);
+        saved.push({
+            id: output.id,
+            type: output.type,
+            path: file,
+            append: output.append ?? false,
+            show_saved: output.show_saved !== false,
+        });
+    }
+    return saved;
+}
+export function resolveOutputFile(config, output, date) {
+    const renderedDir = renderTemplate(output.path, date);
+    const renderedFilename = renderTemplate(output.filename, date);
+    const normalized = renderedDir.replace(/^\.?\//, "");
+    if (normalized === "notes" || normalized.startsWith("notes/")) {
+        const rest = normalized.replace(/^notes\/?/, "");
+        return path.join(config.notes_dir, rest, renderedFilename);
+    }
+    if (path.isAbsolute(normalized)) {
+        return path.join(normalized, renderedFilename);
+    }
+    return path.join(config.workspace, normalized, renderedFilename);
+}
+export function renderTemplate(template, date) {
+    const yyyy = String(date.getFullYear());
+    const MM = String(date.getMonth() + 1).padStart(2, "0");
+    const dd = String(date.getDate()).padStart(2, "0");
+    const isoDate = `${yyyy}-${MM}-${dd}`;
+    return template
+        .replaceAll("{{yyyy}}", yyyy)
+        .replaceAll("{{MM}}", MM)
+        .replaceAll("{{dd}}", dd)
+        .replaceAll("{{date}}", isoDate)
+        .replaceAll("{{datetime}}", date.toISOString());
+}
+async function writeMarkdown(file, output, value, date) {
+    const content = value.content || "";
+    await mkdir(path.dirname(file), { recursive: true });
+    if (output.append) {
+        const existing = await readTextIfExists(file);
+        const prefix = existing ? "" : initialMarkdown(value.frontmatter, date);
+        await writeFile(file, `${prefix}${existing}${ensureTrailingNewline(content)}`, "utf8");
+        return;
+    }
+    await writeFile(file, `${initialFrontmatter(value.frontmatter)}${content}`, "utf8");
+}
+function initialMarkdown(frontmatter, date) {
+    const title = renderTemplate("# {{date}}\n\n", date);
+    return `${initialFrontmatter(frontmatter)}${title}`;
+}
+function initialFrontmatter(frontmatter) {
+    if (!frontmatter || Object.keys(frontmatter).length === 0) {
+        return "";
+    }
+    const lines = ["---"];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (Array.isArray(value)) {
+            lines.push(`${key}: [${value.map((item) => JSON.stringify(item)).join(", ")}]`);
+        }
+        else {
+            lines.push(`${key}: ${JSON.stringify(value)}`);
+        }
+    }
+    lines.push("---", "");
+    return `${lines.join("\n")}\n`;
+}
+function ensureTrailingNewline(value) {
+    return value.endsWith("\n") ? value : `${value}\n`;
+}
+async function readTextIfExists(file) {
+    try {
+        return await readFile(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function assertAllowedOutputPath(config, file) {
+    const resolved = path.resolve(file);
+    const allowedRoots = [path.resolve(config.workspace), path.resolve(config.notes_dir)];
+    if (!allowedRoots.some((root) => resolved === root || resolved.startsWith(`${root}${path.sep}`))) {
+        throw new Error(l(`Output path is outside allowed directories: ${file}`, `出力先が許可された場所の外です: ${file}`));
+    }
+}

package/dist/core/plan-decision.d.ts

@@ -0,0 +1,16 @@
+import type { AppConfig } from "./config.js";
+export type PlanDecision = "approve" | "refine";
+export interface PlanDecisionInput {
+    userText: string;
+    currentPlan: string | null;
+}
+export interface ClassifyPlanDecisionOptions {
+    modelId?: string;
+}
+/**
+ * Classifies whether a user reply during the plan phase is approving the plan
+ * ("approve") or asking to refine/change it ("refine"). LLM-based classification
+ * keeps the call robust across colloquial and multilingual inputs. Slash
+ * commands (`/approve`, `/draft`) and empty input are handled upstream.
+ */
+export declare function classifyPlanDecision(config: AppConfig, input: PlanDecisionInput, options?: ClassifyPlanDecisionOptions): Promise<PlanDecision>;

package/dist/core/plan-decision.js

@@ -0,0 +1,88 @@
+import { getAiProvider } from "./ai-provider.js";
+/**
+ * Classifies whether a user reply during the plan phase is approving the plan
+ * ("approve") or asking to refine/change it ("refine"). LLM-based classification
+ * keeps the call robust across colloquial and multilingual inputs. Slash
+ * commands (`/approve`, `/draft`) and empty input are handled upstream.
+ */
+export async function classifyPlanDecision(config, input, options = {}) {
+    const userText = input.userText.trim();
+    if (!userText) {
+        return "refine";
+    }
+    const system = buildPlanDecisionSystemPrompt();
+    const messages = [
+        { role: "system", content: system },
+        {
+            role: "user",
+            content: buildPlanDecisionUserPrompt({
+                userText,
+                currentPlan: input.currentPlan,
+            }),
+        },
+    ];
+    let response;
+    try {
+        response = await getAiProvider()(config, {
+            model_id: options.modelId || config.chat_model_id,
+            messages,
+            temperature: 0,
+        });
+    }
+    catch {
+        return "refine";
+    }
+    return parseDecision(response.text);
+}
+function buildPlanDecisionSystemPrompt() {
+    return [
+        "You classify Agent-Sin plan approval.",
+        "You will receive the plan just shown to the user and the user's reply to it.",
+        "Decide whether the user is approving the plan or asking to refine/change/add something.",
+        "",
+        "Rules:",
+        "- Short affirmations in any language (OK, yes, go, proceed, please do it, sounds good, leave it to you, 了解, 進めて, お願いします, いいよ, それで, 任せる, etc.) → approve",
+        "- Direct objections or added requirements (want more, also include, remove this, change that, もっと…, 〜も入れて, 〜は要らない, 〜を変えて, etc.) → refine",
+        "- Questions or confirmations → refine",
+        "- Ignore punctuation, emojis, politeness, and tone differences. Judge by meaning.",
+        "- If unsure, choose refine so the user's extra information is not lost.",
+        "",
+        "Return exactly one JSON object. No explanation and no ``` fences:",
+        '{"decision":"approve|refine","reason":"short reason"}',
+    ].join("\n");
+}
+function buildPlanDecisionUserPrompt(args) {
+    const lines = [];
+    if (args.currentPlan) {
+        lines.push("<current_plan>");
+        lines.push(args.currentPlan);
+        lines.push("</current_plan>");
+    }
+    else {
+        lines.push("<current_plan>(no plan generated)</current_plan>");
+    }
+    lines.push("<user_reply>");
+    lines.push(args.userText);
+    lines.push("</user_reply>");
+    lines.push("Return JSON only.");
+    return lines.join("\n");
+}
+function parseDecision(text) {
+    const stripped = text
+        .replace(/```json\s*/gi, "")
+        .replace(/```\s*$/g, "")
+        .trim();
+    const start = stripped.indexOf("{");
+    const end = stripped.lastIndexOf("}");
+    if (start < 0 || end <= start) {
+        return "refine";
+    }
+    try {
+        const parsed = JSON.parse(stripped.slice(start, end + 1));
+        const raw = String(parsed.decision || "").trim().toLowerCase();
+        return raw === "approve" ? "approve" : "refine";
+    }
+    catch {
+        return "refine";
+    }
+}

package/dist/core/profile-memory.d.ts

@@ -0,0 +1,17 @@
+import type { AppConfig } from "./config.js";
+export type ProfileMemoryTarget = "soul" | "user" | "memory";
+export interface ProfileMemoryFiles {
+    soul: string;
+    user: string;
+    memory: string;
+    paths: Record<ProfileMemoryTarget, string>;
+}
+export declare function profileMemoryDir(config: AppConfig): string;
+export declare function profileMemoryPath(config: AppConfig, target: ProfileMemoryTarget): string;
+export declare function ensureProfileMemoryFiles(config: AppConfig): Promise<ProfileMemoryFiles>;
+export declare function readProfileMemoryFiles(config: AppConfig): Promise<ProfileMemoryFiles>;
+export declare function readProfileMemoryForPrompt(config: AppConfig): Promise<ProfileMemoryFiles>;
+export declare function appendProfileMemory(config: AppConfig, target: ProfileMemoryTarget, text: string, date?: Date): Promise<string>;
+export declare function parseProfileMemoryTarget(value: string | undefined): ProfileMemoryTarget | undefined;
+export declare function formatProfileEntry(text: string, date?: Date): string;
+export declare function formatProfileMemoryPromptSection(profileMemory: ProfileMemoryFiles | undefined): string[];

package/dist/core/profile-memory.js

@@ -0,0 +1,142 @@
+import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { l } from "./i18n.js";
+const SOUL_TEMPLATE_EN = `# soul.md
+
+<!--
+Long-term notes about the AI itself.
+Write explicit user-provided guidance for role, tone, judgment criteria, and durable behavior here.
+-->
+`;
+const SOUL_TEMPLATE_JA = `# soul.md
+
+<!--
+AI自身についての長期メモを書く場所です。
+役割、話し方、判断基準、継続したい姿勢などをユーザーが明示的に書きます。
+-->
+`;
+const USER_TEMPLATE_EN = `# user.md
+
+<!--
+Long-term notes about the user.
+Write explicit user-provided preferences, work context, things to avoid, and durable assumptions here.
+-->
+`;
+const USER_TEMPLATE_JA = `# user.md
+
+<!--
+ユーザーについての長期メモを書く場所です。
+好み、作業文脈、避けたいこと、長期的な前提などをユーザーが明示的に書きます。
+-->
+`;
+const MEMORY_TEMPLATE_EN = `# memory.md
+
+<!--
+Long-term notes for understanding the user deeply and keeping conversations smooth.
+Unlike user.md (fixed profile), this file stores updateable observations such as preferences, values, and communication patterns.
+Edit and update existing items when new information arrives instead of only appending.
+Do not write operating rules, schedules, or skill behavior settings here.
+-->
+`;
+const MEMORY_TEMPLATE_JA = `# memory.md
+
+<!--
+ユーザーを深く理解し会話をスムーズにするための長期メモ。
+user.md（固定プロフィール）に対し、こちらは嗜好・価値観・コミュニケーション傾向など
+更新されうる観察を1行ずつ書く。新情報が入ったら追記ではなく既存項目を編集・更新していく。
+運用ルール・スケジュール・スキル動作の設定はここに書かない。
+-->
+`;
+export function profileMemoryDir(config) {
+    return path.join(config.memory_dir, "profile");
+}
+export function profileMemoryPath(config, target) {
+    return path.join(profileMemoryDir(config), `${target}.md`);
+}
+export async function ensureProfileMemoryFiles(config) {
+    const paths = profileMemoryPaths(config);
+    await mkdir(profileMemoryDir(config), { recursive: true });
+    await writeIfMissing(paths.soul, l(SOUL_TEMPLATE_EN, SOUL_TEMPLATE_JA));
+    await writeIfMissing(paths.user, l(USER_TEMPLATE_EN, USER_TEMPLATE_JA));
+    await writeIfMissing(paths.memory, l(MEMORY_TEMPLATE_EN, MEMORY_TEMPLATE_JA));
+    return {
+        soul: await readFile(paths.soul, "utf8"),
+        user: await readFile(paths.user, "utf8"),
+        memory: await readFile(paths.memory, "utf8"),
+        paths,
+    };
+}
+export async function readProfileMemoryFiles(config) {
+    const files = await ensureProfileMemoryFiles(config);
+    return files;
+}
+export async function readProfileMemoryForPrompt(config) {
+    const files = await ensureProfileMemoryFiles(config);
+    return {
+        soul: promptContent(files.soul, "soul"),
+        user: promptContent(files.user, "user"),
+        memory: promptContent(files.memory, "memory"),
+        paths: files.paths,
+    };
+}
+export async function appendProfileMemory(config, target, text, date = new Date()) {
+    const value = text.trim();
+    if (!value) {
+        throw new Error(l("Profile text is empty", "プロフィールメモが空です"));
+    }
+    await ensureProfileMemoryFiles(config);
+    const file = profileMemoryPath(config, target);
+    await appendFile(file, formatProfileEntry(value, date), "utf8");
+    return file;
+}
+export function parseProfileMemoryTarget(value) {
+    if (value === "soul" || value === "user" || value === "memory") {
+        return value;
+    }
+    return undefined;
+}
+export function formatProfileEntry(text, date = new Date()) {
+    return `\n## ${date.toISOString()}\n\n${text.trim()}\n`;
+}
+export function formatProfileMemoryPromptSection(profileMemory) {
+    if (!profileMemory) {
+        return [];
+    }
+    const lines = [];
+    if (profileMemory.soul.trim()) {
+        lines.push("<soul.md>", profileMemory.soul.trim(), "</soul.md>");
+    }
+    if (profileMemory.user.trim()) {
+        lines.push("<user.md>", profileMemory.user.trim(), "</user.md>");
+    }
+    if (profileMemory.memory.trim()) {
+        lines.push("<memory.md>", profileMemory.memory.trim(), "</memory.md>");
+    }
+    return lines;
+}
+function profileMemoryPaths(config) {
+    return {
+        soul: profileMemoryPath(config, "soul"),
+        user: profileMemoryPath(config, "user"),
+        memory: profileMemoryPath(config, "memory"),
+    };
+}
+async function writeIfMissing(file, content) {
+    try {
+        await stat(file);
+    }
+    catch {
+        await writeFile(file, content, "utf8");
+    }
+}
+function promptContent(raw, target) {
+    const withoutComments = raw.replace(/<!--[\s\S]*?-->/g, "").trim();
+    if (!withoutComments) {
+        return "";
+    }
+    const lines = withoutComments.split(/\r?\n/);
+    if (lines[0]?.trim().toLowerCase() === `# ${target}.md`) {
+        lines.shift();
+    }
+    return lines.join("\n").trim();
+}

package/dist/core/runtime.d.ts

@@ -0,0 +1,50 @@
+import type { AppConfig } from "./config.js";
+import { type SavedOutput } from "./output-writer.js";
+import { type SkillManifest } from "./skill-registry.js";
+import type { SkillResult } from "../skills-sdk/types.js";
+export interface RunSkillResponse {
+    run_id: string;
+    manifest: SkillManifest;
+    result: SkillResult;
+    saved_outputs: SavedOutput[];
+    log_path: string;
+    memory_path?: string;
+    attempts: number;
+}
+export interface RunSkillOptions {
+    /** @deprecated Approval gating was removed; field kept for API compatibility. */
+    approved?: boolean;
+    dryRun?: boolean;
+}
+export interface SkillLogEntry {
+    level: "info" | "warn" | "error";
+    message: string;
+    ts?: string;
+}
+export interface SkillExecution {
+    result: SkillResult;
+    memory_updates?: Record<string, unknown>;
+    logs?: SkillLogEntry[];
+}
+export declare class SkillRunError extends Error {
+    readonly runId: string;
+    readonly skillId: string;
+    readonly logPath: string;
+    readonly originalMessage: string;
+    constructor(message: string, runId: string, skillId: string, logPath: string, originalMessage: string);
+}
+export declare function runSkill(config: AppConfig, skillId: string, args: Record<string, unknown>, options?: RunSkillOptions): Promise<RunSkillResponse>;
+export declare class MissingEnvError extends Error {
+    readonly missing: Array<{
+        name: string;
+        description?: string;
+    }>;
+    constructor(missing: Array<{
+        name: string;
+        description?: string;
+    }>);
+}
+export declare function findMissingRequiredEnv(manifest: SkillManifest): Array<{
+    name: string;
+    description?: string;
+}>;

package/dist/core/runtime.js

@@ -0,0 +1,187 @@
+import path from "node:path";
+import { appendEventLog, createRunId, writeRunLog } from "./logger.js";
+import { loadSkillMemory, saveSkillMemoryUpdates } from "./memory.js";
+import { writeSkillOutputs } from "./output-writer.js";
+import { findSkillManifest } from "./skill-registry.js";
+import { validateSkillArgs } from "./input-schema.js";
+import { loadDotenv } from "./secrets.js";
+import { ensureProfileMemoryFiles } from "./profile-memory.js";
+import { runPythonSkill } from "../runtimes/python-runner.js";
+import { runTypeScriptSkill } from "../runtimes/typescript-runner.js";
+import { detectLocale, l, t } from "./i18n.js";
+export class SkillRunError extends Error {
+    runId;
+    skillId;
+    logPath;
+    originalMessage;
+    constructor(message, runId, skillId, logPath, originalMessage) {
+        super(message);
+        this.runId = runId;
+        this.skillId = skillId;
+        this.logPath = logPath;
+        this.originalMessage = originalMessage;
+        this.name = "SkillRunError";
+    }
+}
+export async function runSkill(config, skillId, args, options = {}) {
+    await loadDotenv(config.workspace);
+    await ensureProfileMemoryFiles(config);
+    const manifest = await findSkillManifest(config.skills_dir, skillId);
+    if (manifest.enabled === false) {
+        throw new Error(l(`Skill is disabled: ${skillId}`, `スキルが無効です: ${skillId}`));
+    }
+    assertRequiredEnv(manifest);
+    const runId = createRunId();
+    const started = new Date();
+    const memory = await loadSkillMemory(config, manifest);
+    const input = {
+        args,
+        trigger: {
+            type: "manual",
+            id: "manual",
+            time: started.toISOString(),
+        },
+        sources: {
+            workspace: config.workspace,
+            notes_dir: config.notes_dir,
+            memory_dir: config.memory_dir,
+            index_dir: config.index_dir,
+            logs_dir: config.logs_dir,
+            locale: detectLocale(),
+        },
+        memory,
+    };
+    input.args = validateSkillArgs(manifest, args);
+    let attempts = 0;
+    let lastError;
+    try {
+        const maxAttempts = Math.max(0, manifest.retry?.max_attempts || 0);
+        for (let attempt = 0; attempt <= maxAttempts; attempt += 1) {
+            attempts = attempt + 1;
+            try {
+                const execution = await executeSkill(config, manifest, input);
+                const result = normalizeResult(execution.result);
+                if (result.status === "error" && attempt < maxAttempts) {
+                    await waitRetryDelay(manifest);
+                    continue;
+                }
+                const savedOutputs = result.status === "ok" && !options.dryRun ? await writeSkillOutputs(config, manifest, result, started) : [];
+                const memoryPath = result.status === "ok" && !options.dryRun
+                    ? await saveSkillMemoryUpdates(config, manifest, execution.memory_updates || {})
+                    : undefined;
+                const finished = new Date().toISOString();
+                const skillLogs = execution.logs || [];
+                const logPath = await writeRunLog(config, {
+                    run_id: runId,
+                    skill_id: manifest.id,
+                    status: result.status,
+                    started_at: started.toISOString(),
+                    finished_at: finished,
+                    attempts,
+                    input,
+                    result,
+                    saved_outputs: savedOutputs,
+                    memory_path: memoryPath,
+                    dry_run: options.dryRun ? true : undefined,
+                    ctx_logs: skillLogs.length > 0 ? skillLogs : undefined,
+                });
+                for (const entry of skillLogs) {
+                    await appendEventLog(config, {
+                        ts: entry.ts,
+                        level: entry.level,
+                        source: "skill",
+                        event: "ctx_log",
+                        message: entry.message,
+                        details: { skill_id: manifest.id, run_id: runId, dry_run: options.dryRun ? true : undefined },
+                    });
+                }
+                return {
+                    run_id: runId,
+                    manifest,
+                    result,
+                    saved_outputs: savedOutputs,
+                    log_path: logPath,
+                    memory_path: memoryPath,
+                    attempts,
+                };
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxAttempts) {
+                    await waitRetryDelay(manifest);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
+    catch (error) {
+        const finished = new Date().toISOString();
+        const logPath = await writeRunLog(config, {
+            run_id: runId,
+            skill_id: manifest.id,
+            status: "error",
+            started_at: started.toISOString(),
+            finished_at: finished,
+            attempts,
+            input,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        const message = error instanceof Error ? error.message : String(error);
+        throw new SkillRunError(`${message} (log: ${path.basename(logPath)})`, runId, manifest.id, logPath, message);
+    }
+}
+async function executeSkill(config, manifest, input) {
+    if (manifest.runtime === "python") {
+        return runPythonSkill(config, manifest, input);
+    }
+    if (manifest.runtime === "typescript") {
+        return runTypeScriptSkill(config, manifest, input);
+    }
+    throw new Error(l(`Unsupported runtime: ${manifest.runtime}`, `未対応の runtime です: ${manifest.runtime}`));
+}
+export class MissingEnvError extends Error {
+    missing;
+    constructor(missing) {
+        super(l(`Missing required env vars: ${missing.map((entry) => entry.name).join(", ")}`, `必要な環境変数が未設定です: ${missing.map((entry) => entry.name).join(", ")}`));
+        this.missing = missing;
+        this.name = "MissingEnvError";
+    }
+}
+export function findMissingRequiredEnv(manifest) {
+    if (!manifest.required_env || manifest.required_env.length === 0)
+        return [];
+    const missing = [];
+    for (const entry of manifest.required_env) {
+        if (entry.optional)
+            continue;
+        const value = process.env[entry.name];
+        if (!value || value.trim() === "") {
+            missing.push({ name: entry.name, description: entry.description });
+        }
+    }
+    return missing;
+}
+function assertRequiredEnv(manifest) {
+    const missing = findMissingRequiredEnv(manifest);
+    if (missing.length > 0) {
+        throw new MissingEnvError(missing);
+    }
+}
+async function waitRetryDelay(manifest) {
+    const delay = manifest.retry?.delay_ms || 0;
+    if (delay > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+}
+function normalizeResult(result) {
+    return {
+        status: result.status || "ok",
+        title: result.title || t("skill.default_done"),
+        summary: result.summary || "",
+        outputs: result.outputs || {},
+        data: result.data || {},
+        suggestions: result.suggestions || [],
+    };
+}

package/dist/core/scheduler.d.ts

@@ -0,0 +1,28 @@
+export interface ScheduleEntry {
+    id: string;
+    cron: string;
+    skill: string;
+    enabled: boolean;
+    args: Record<string, unknown>;
+    approve: boolean;
+    description?: string;
+    expression: CronExpression;
+}
+export interface CronExpression {
+    raw: string;
+    minute: CronField;
+    hour: CronField;
+    dayOfMonth: CronField;
+    month: CronField;
+    dayOfWeek: CronField;
+}
+export interface CronField {
+    values: Set<number>;
+    isWildcard: boolean;
+}
+export declare function loadSchedules(workspace: string): Promise<ScheduleEntry[]>;
+export declare function schedulesFile(workspace: string): string;
+export declare function legacySchedulesFile(workspace: string): string;
+export declare function parseCron(raw: string): CronExpression;
+export declare function matchesCron(expression: CronExpression, date: Date): boolean;
+export declare function nextRunAfter(expression: CronExpression, from: Date, lookaheadMinutes?: number): Date | null;