@gh-symphony/cli 0.0.1 → 0.0.2

package/dist/github/client.js

@@ -8,6 +8,16 @@ export class GitHubApiError extends Error {
         this.name = "GitHubApiError";
     }
 }
+export class GitHubScopeError extends GitHubApiError {
+    requiredScopes;
+    currentScopes;
+    constructor(message, requiredScopes, currentScopes) {
+        super(message);
+        this.requiredScopes = requiredScopes;
+        this.currentScopes = currentScopes;
+        this.name = "GitHubScopeError";
+    }
+}
 export function createClient(token, options) {
     return {
         token,
@@ -94,19 +104,29 @@ export async function getProjectDetail(client, projectId) {
         throw new GitHubApiError(`Project not found: ${projectId}`);
     }
     const statusFields = [];
+    const textFields = [];
     for (const field of project.fields?.nodes ?? []) {
-        if (!field || field.__typename !== "ProjectV2SingleSelectField")
+        if (!field)
             continue;
-        statusFields.push({
-            id: field.id,
-            name: field.name,
-            options: (field.options ?? []).map((opt) => ({
-                id: opt.id,
-                name: opt.name,
-                description: opt.description ?? null,
-                color: opt.color ?? null,
-            })),
-        });
+        if (field.__typename === "ProjectV2SingleSelectField") {
+            statusFields.push({
+                id: field.id,
+                name: field.name,
+                options: (field.options ?? []).map((opt) => ({
+                    id: opt.id,
+                    name: opt.name,
+                    description: opt.description ?? null,
+                    color: opt.color ?? null,
+                })),
+            });
+        }
+        else if (field.__typename === "ProjectV2Field" && field.dataType) {
+            textFields.push({
+                id: field.id,
+                name: field.name,
+                dataType: field.dataType,
+            });
+        }
     }
     const repoMap = new Map();
     let cursor = null;
@@ -156,6 +176,7 @@ export async function getProjectDetail(client, projectId) {
         title: project.title,
         url: project.url,
         statusFields,
+        textFields,
         linkedRepositories: [...repoMap.values()],
     };
 }
@@ -175,6 +196,28 @@ async function graphql(client, query, variables) {
     }
     const payload = (await response.json());
     if (payload.errors?.length) {
+        const scopeMessages = payload.errors
+            .map((e) => e.message)
+            .filter((m) => m.includes("has not been granted the required scopes"));
+        if (scopeMessages.length > 0) {
+            const requiredScopes = new Set();
+            let currentScopes = [];
+            for (const msg of scopeMessages) {
+                for (const match of msg.matchAll(/requires one of the following scopes: \['([^']+)'\]/g)) {
+                    requiredScopes.add(match[1]);
+                }
+                if (currentScopes.length === 0) {
+                    const currMatch = /has only been granted the: \[([^\]]+)\]/.exec(msg);
+                    if (currMatch) {
+                        currentScopes = currMatch[1]
+                            .split(",")
+                            .map((s) => s.trim().replace(/'/g, ""))
+                            .filter(Boolean);
+                    }
+                }
+            }
+            throw new GitHubScopeError("Token is missing required GitHub scopes.", [...requiredScopes], currentScopes);
+        }
         throw new GitHubApiError(`GraphQL errors: ${payload.errors.map((e) => e.message).join("; ")}`);
     }
     if (!payload.data) {
@@ -234,6 +277,11 @@ const PROJECT_DETAIL_QUERY = `
                 color
               }
             }
+            ... on ProjectV2Field {
+              id
+              name
+              dataType
+            }
           }
         }
         items(first: 100) {

package/dist/github/gh-auth.d.ts

@@ -0,0 +1,34 @@
+import { execFileSync, spawnSync } from "node:child_process";
+type ExecImpl = typeof execFileSync;
+type SpawnImpl = typeof spawnSync;
+export declare class GhAuthError extends Error {
+    readonly code: "not_installed" | "not_authenticated" | "missing_scopes" | "token_failed";
+    constructor(code: "not_installed" | "not_authenticated" | "missing_scopes" | "token_failed", message: string);
+}
+export declare function checkGhInstalled(opts?: {
+    execImpl?: ExecImpl;
+}): boolean;
+export declare function checkGhAuthenticated(opts?: {
+    spawnImpl?: SpawnImpl;
+}): {
+    authenticated: boolean;
+    login?: string;
+};
+export declare function checkGhScopes(opts?: {
+    spawnImpl?: SpawnImpl;
+}): {
+    valid: boolean;
+    missing: string[];
+    scopes: string[];
+};
+export declare function getGhToken(opts?: {
+    execImpl?: ExecImpl;
+}): string;
+export declare function ensureGhAuth(opts?: {
+    execImpl?: ExecImpl;
+    spawnImpl?: SpawnImpl;
+}): {
+    login: string;
+    token: string;
+};
+export {};

package/dist/github/gh-auth.js

@@ -0,0 +1,110 @@
+import { execFileSync, spawnSync } from "node:child_process";
+const REQUIRED_SCOPES = ["repo", "read:org", "project"];
+export class GhAuthError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "GhAuthError";
+    }
+}
+export function checkGhInstalled(opts) {
+    const execImpl = opts?.execImpl ?? execFileSync;
+    try {
+        execImpl("gh", ["--version"], { stdio: "pipe" });
+        return true;
+    }
+    catch (error) {
+        const execError = error;
+        if (execError.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+export function checkGhAuthenticated(opts) {
+    const spawnImpl = opts?.spawnImpl ?? spawnSync;
+    const result = spawnImpl("gh", ["auth", "status"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if ((result.status ?? 1) !== 0) {
+        return { authenticated: false };
+    }
+    const login = parseLogin((result.stderr ?? "").toString());
+    return { authenticated: true, login };
+}
+export function checkGhScopes(opts) {
+    const spawnImpl = opts?.spawnImpl ?? spawnSync;
+    const result = spawnImpl("gh", ["auth", "status"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const output = (result.stderr ?? "").toString();
+    const scopes = parseScopes(output);
+    if (scopes.length === 0) {
+        return { valid: true, missing: [], scopes: [] };
+    }
+    const normalized = scopes.map((scope) => scope.toLowerCase());
+    const missing = REQUIRED_SCOPES.filter((scope) => !normalized.includes(scope));
+    return {
+        valid: missing.length === 0,
+        missing: [...missing],
+        scopes,
+    };
+}
+export function getGhToken(opts) {
+    if (process.env.GITHUB_GRAPHQL_TOKEN) {
+        return process.env.GITHUB_GRAPHQL_TOKEN;
+    }
+    const execImpl = opts?.execImpl ?? execFileSync;
+    try {
+        const token = execImpl("gh", ["auth", "token"], {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        })
+            .toString()
+            .trim();
+        if (!token) {
+            throw new GhAuthError("token_failed", "gh auth token 실패. gh auth status 를 확인하세요.");
+        }
+        return token;
+    }
+    catch (error) {
+        if (error instanceof GhAuthError) {
+            throw error;
+        }
+        throw new GhAuthError("token_failed", "gh auth token 실패. gh auth status 를 확인하세요.");
+    }
+}
+export function ensureGhAuth(opts) {
+    const execImpl = opts?.execImpl ?? execFileSync;
+    const spawnImpl = opts?.spawnImpl ?? spawnSync;
+    if (!checkGhInstalled({ execImpl })) {
+        throw new GhAuthError("not_installed", "gh CLI가 설치되어 있지 않습니다. https://cli.github.com 에서 설치하세요.");
+    }
+    const auth = checkGhAuthenticated({ spawnImpl });
+    if (!auth.authenticated) {
+        throw new GhAuthError("not_authenticated", "gh auth login --scopes repo,read:org,project 를 실행하세요.");
+    }
+    const scopeCheck = checkGhScopes({ spawnImpl });
+    if (!scopeCheck.valid) {
+        throw new GhAuthError("missing_scopes", `gh auth refresh --scopes repo,read:org,project 를 실행하세요. (missing: ${scopeCheck.missing.join(", ")})`);
+    }
+    const token = getGhToken({ execImpl });
+    return { login: auth.login ?? "unknown", token };
+}
+function parseLogin(output) {
+    const matched = output.match(/Logged in to github\.com account\s+\*?\*?([A-Za-z0-9_-]+)\*?\*?/i);
+    return matched?.[1];
+}
+function parseScopes(output) {
+    const matched = output.match(/Token scopes:\s*(.+)/i);
+    if (!matched) {
+        return [];
+    }
+    return matched[1]
+        .split(",")
+        .map((scope) => scope.trim().replace(/^'+|'+$/g, ""))
+        .filter((scope) => scope.length > 0);
+}

package/dist/index.js

@@ -48,6 +48,7 @@ const COMMANDS = {
     logs: () => import("./commands/logs.js"),
     project: () => import("./commands/project.js"),
     repo: () => import("./commands/repo.js"),
+    tenant: () => import("./commands/tenant.js"),
     config: () => import("./commands/config-cmd.js"),
     help: () => import("./commands/help.js"),
     version: () => import("./commands/version.js"),

package/dist/mapping/smart-defaults.d.ts

@@ -1,33 +1,17 @@
-import type { WorkflowLifecycleConfig } from "@hojinzs/gh-symphony-core";
-import type { ColumnRole, HumanReviewMode } from "../config.js";
-export type ColumnMapping = {
+import type { WorkflowLifecycleConfig } from "@gh-symphony/core";
+import type { StateRole, StateMapping } from "../config.js";
+export type StateRoleMapping = {
     columnName: string;
-    role: ColumnRole | null;
+    role: StateRole | null;
     confidence: "high" | "low";
 };
-export declare function inferColumnRole(columnName: string): ColumnMapping;
-export declare function inferAllColumnRoles(columnNames: string[]): ColumnMapping[];
-export type PhaseMapping = {
-    planningStates: string[];
-    humanReviewStates: string[];
-    implementationStates: string[];
-    awaitingMergeStates: string[];
-    completedStates: string[];
-};
-/**
- * Map column roles to Symphony execution phases based on the human-review mode.
- *
- * Modes:
- * - plan-and-pr: Human reviews both plans and PRs (full review pipeline)
- * - plan-only: Human reviews plans, PRs auto-merge
- * - pr-only: No plan review, human reviews PRs
- * - none: No human review at all (full auto)
- */
-export declare function buildPhaseMapping(roles: Record<string, ColumnRole>, mode: HumanReviewMode): PhaseMapping;
-export declare function toWorkflowLifecycleConfig(stateFieldName: string, roles: Record<string, ColumnRole>, mode: HumanReviewMode): WorkflowLifecycleConfig;
+export declare function inferStateRole(columnName: string): StateRoleMapping;
+export declare function inferAllStateRoles(columnNames: string[]): StateRoleMapping[];
+export declare function toWorkflowLifecycleConfig(stateFieldName: string, mappings: Record<string, StateMapping>): WorkflowLifecycleConfig;
 export type MappingValidationResult = {
     valid: boolean;
     errors: string[];
     warnings: string[];
 };
-export declare function validateMapping(roles: Record<string, ColumnRole>): MappingValidationResult;
+export declare function validateStateMapping(mappings: Record<string, StateMapping>): MappingValidationResult;
+export declare function generateStatusMap(mappings: Record<string, StateMapping>): string;

package/dist/mapping/smart-defaults.js

@@ -1,27 +1,19 @@
 // ── 3.1: Smart defaults pattern matching ─────────────────────────────────────
 const ROLE_PATTERNS = [
     {
-        role: "trigger",
-        pattern: /^(todo|to.do|to-do|ready|queued|open|new|triage)$/i,
+        role: "active",
+        pattern: /^(todo|to.do|to-do|ready|queued|open|new|triage|in.progress|working|active|doing|in.development|developing|wip)$/i,
     },
     {
-        role: "working",
-        pattern: /^(in.progress|working|active|doing|in.development|developing|wip)$/i,
+        role: "wait",
+        pattern: /^(review|in.review|pr.review|needs.review|plan.review|awaiting.review|code.review|icebox|someday|later|blocked|on.hold|paused|deferred|draft|backlog)$/i,
     },
     {
-        role: "human-review",
-        pattern: /^(review|in.review|pr.review|needs.review|plan.review|awaiting.review|code.review)$/i,
-    },
-    {
-        role: "done",
-        pattern: /^(done|completed?|closed|merged|shipped|resolved|finished)$/i,
-    },
-    {
-        role: "ignored",
-        pattern: /^(icebox|someday|later|blocked|on.hold|paused|won.?t.do|cancelled|deferred|draft|backlog)$/i,
+        role: "terminal",
+        pattern: /^(done|completed?|closed|merged|shipped|resolved|finished|won.?t.do|cancelled)$/i,
     },
 ];
-export function inferColumnRole(columnName) {
+export function inferStateRole(columnName) {
     const normalized = columnName.trim();
     for (const { role, pattern } of ROLE_PATTERNS) {
         if (pattern.test(normalized)) {
@@ -30,130 +22,65 @@ export function inferColumnRole(columnName) {
     }
     return { columnName: normalized, role: null, confidence: "low" };
 }
-export function inferAllColumnRoles(columnNames) {
-    return columnNames.map(inferColumnRole);
+export function inferAllStateRoles(columnNames) {
+    return columnNames.map(inferStateRole);
 }
-/**
- * Map column roles to Symphony execution phases based on the human-review mode.
- *
- * Modes:
- * - plan-and-pr: Human reviews both plans and PRs (full review pipeline)
- * - plan-only: Human reviews plans, PRs auto-merge
- * - pr-only: No plan review, human reviews PRs
- * - none: No human review at all (full auto)
- */
-export function buildPhaseMapping(roles, mode) {
-    const planningStates = [];
-    const humanReviewStates = [];
-    const implementationStates = [];
-    const awaitingMergeStates = [];
-    const completedStates = [];
-    for (const [columnName, role] of Object.entries(roles)) {
-        switch (role) {
-            case "trigger":
-                planningStates.push(columnName);
-                break;
-            case "working":
-                implementationStates.push(columnName);
+// ── 3.2: Mapping → WorkflowLifecycleConfig conversion ───────────────────────
+export function toWorkflowLifecycleConfig(stateFieldName, mappings) {
+    const activeStates = [];
+    const terminalStates = [];
+    const blockerCheckStates = [];
+    for (const [columnName, mapping] of Object.entries(mappings)) {
+        switch (mapping.role) {
+            case "active":
+                activeStates.push(columnName);
                 break;
-            case "human-review":
-                switch (mode) {
-                    case "plan-and-pr":
-                        humanReviewStates.push(columnName);
-                        break;
-                    case "plan-only":
-                        humanReviewStates.push(columnName);
-                        break;
-                    case "pr-only":
-                        awaitingMergeStates.push(columnName);
-                        break;
-                    case "none":
-                        // In "none" mode, review columns are treated as implementation
-                        implementationStates.push(columnName);
-                        break;
-                }
+            case "terminal":
+                terminalStates.push(columnName);
                 break;
-            case "done":
-                completedStates.push(columnName);
-                break;
-            case "ignored":
-                // Ignored columns don't map to any phase
+            case "wait":
+                // Wait states are neither active nor terminal
                 break;
         }
     }
-    return {
-        planningStates,
-        humanReviewStates,
-        implementationStates,
-        awaitingMergeStates,
-        completedStates,
-    };
-}
-// ── 3.3: Mapping → WorkflowLifecycleConfig conversion ───────────────────────
-export function toWorkflowLifecycleConfig(stateFieldName, roles, mode) {
-    const phases = buildPhaseMapping(roles, mode);
-    // Transition targets: where issues move when a phase completes
-    const planningCompleteState = resolveTransitionTarget(phases, "planning", mode);
-    const implementationCompleteState = resolveTransitionTarget(phases, "implementation", mode);
-    const mergeCompleteState = phases.completedStates[0] ?? phases.awaitingMergeStates[0] ?? "Done";
+    // Default blocker check: first active state (typically "Todo"-like)
+    if (activeStates.length > 0) {
+        blockerCheckStates.push(activeStates[0]);
+    }
     return {
         stateFieldName,
-        planningStates: phases.planningStates,
-        humanReviewStates: phases.humanReviewStates,
-        implementationStates: phases.implementationStates,
-        awaitingMergeStates: phases.awaitingMergeStates,
-        completedStates: phases.completedStates,
-        planningCompleteState,
-        implementationCompleteState,
-        mergeCompleteState,
+        activeStates,
+        terminalStates,
+        blockerCheckStates,
     };
 }
-function resolveTransitionTarget(phases, fromPhase, mode) {
-    if (fromPhase === "planning") {
-        // After planning: go to human-review (if exists) or implementation
-        if ((mode === "plan-and-pr" || mode === "plan-only") &&
-            phases.humanReviewStates.length > 0) {
-            return phases.humanReviewStates[0];
-        }
-        return phases.implementationStates[0] ?? "In Progress";
-    }
-    // After implementation: go to awaiting-merge (if exists) or completed
-    if ((mode === "plan-and-pr" || mode === "pr-only") &&
-        phases.awaitingMergeStates.length > 0) {
-        return phases.awaitingMergeStates[0];
-    }
-    return phases.completedStates[0] ?? "Done";
-}
-export function validateMapping(roles) {
+export function validateStateMapping(mappings) {
     const errors = [];
     const warnings = [];
-    const roleEntries = Object.entries(roles);
-    const triggerColumns = roleEntries.filter(([, r]) => r === "trigger");
-    const workingColumns = roleEntries.filter(([, r]) => r === "working");
-    const doneColumns = roleEntries.filter(([, r]) => r === "done");
-    const reviewColumns = roleEntries.filter(([, r]) => r === "human-review");
-    // Required roles
-    if (triggerColumns.length === 0) {
-        errors.push("Missing required role: 'trigger' — at least one column must trigger work.");
-    }
-    if (workingColumns.length === 0) {
-        errors.push("Missing required role: 'working' — at least one column must represent active work.");
+    const entries = Object.entries(mappings);
+    const activeEntries = entries.filter(([, m]) => m.role === "active");
+    const terminalEntries = entries.filter(([, m]) => m.role === "terminal");
+    // Required: at least one active and one terminal
+    if (activeEntries.length === 0) {
+        errors.push("Missing required role: 'active' — at least one state must be active.");
     }
-    if (doneColumns.length === 0) {
-        errors.push("Missing required role: 'done' — at least one column must represent completion.");
+    if (terminalEntries.length === 0) {
+        errors.push("Missing required role: 'terminal' — at least one state must be terminal.");
     }
-    // Warnings for unusual setups
-    if (triggerColumns.length > 1) {
-        warnings.push(`Multiple trigger columns: ${triggerColumns.map(([n]) => n).join(", ")}. ` +
-            "All will be treated as planning states.");
-    }
-    if (doneColumns.length > 1) {
-        warnings.push(`Multiple done columns: ${doneColumns.map(([n]) => n).join(", ")}. ` +
-            "All will be treated as completed states.");
-    }
-    if (reviewColumns.length > 2) {
-        warnings.push(`${reviewColumns.length} review columns detected. ` +
-            "Consider simplifying to one or two review stages.");
+    // Warnings
+    if (terminalEntries.length > 1) {
+        warnings.push(`Multiple terminal states: ${terminalEntries.map(([n]) => n).join(", ")}. ` +
+            "All will be treated as terminal states.");
     }
     return { valid: errors.length === 0, errors, warnings };
 }
+// ── 3.5: Status Map generation ──────────────────────────────────────────────
+export function generateStatusMap(mappings) {
+    const lines = ["## Status Map", ""];
+    for (const [columnName, mapping] of Object.entries(mappings)) {
+        const rolePart = `[${mapping.role}]`;
+        const goalPart = mapping.goal ? ` — ${mapping.goal}` : "";
+        lines.push(`- **${columnName}** ${rolePart}${goalPart}`);
+    }
+    return lines.join("\n");
+}

package/dist/orchestrator-runtime.d.ts

@@ -1,5 +1,5 @@
-import { type CliWorkspaceConfig } from "./config.js";
+import { type CliTenantConfig } from "./config.js";
 export declare function resolveRuntimeRoot(configDir: string): string;
-export declare function resolveWorkspaceConfig(configDir: string, requestedWorkspaceId?: string): Promise<CliWorkspaceConfig | null>;
-export declare function orchestratorWorkspaceConfigPath(runtimeRoot: string, workspaceId: string): string;
-export declare function syncWorkspaceToRuntime(configDir: string, workspaceConfig: CliWorkspaceConfig): Promise<string>;
+export declare function resolveTenantConfig(configDir: string, requestedTenantId?: string): Promise<CliTenantConfig | null>;
+export declare function orchestratorTenantConfigPath(runtimeRoot: string, tenantId: string): string;
+export declare function syncTenantToRuntime(configDir: string, tenantConfig: CliTenantConfig): Promise<string>;

package/dist/orchestrator-runtime.js

@@ -1,26 +1,41 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
-import { loadGlobalConfig, loadWorkspaceConfig, } from "./config.js";
+import { loadGlobalConfig, loadTenantConfig, } from "./config.js";
 export function resolveRuntimeRoot(configDir) {
     return resolve(configDir);
 }
-export async function resolveWorkspaceConfig(configDir, requestedWorkspaceId) {
-    if (requestedWorkspaceId) {
-        return loadWorkspaceConfig(configDir, requestedWorkspaceId);
+export async function resolveTenantConfig(configDir, requestedTenantId) {
+    if (requestedTenantId) {
+        return loadTenantConfig(configDir, requestedTenantId);
     }
     const global = await loadGlobalConfig(configDir);
-    if (!global?.activeWorkspace) {
+    if (!global?.activeTenant) {
         return null;
     }
-    return loadWorkspaceConfig(configDir, global.activeWorkspace);
+    return loadTenantConfig(configDir, global.activeTenant);
 }
-export function orchestratorWorkspaceConfigPath(runtimeRoot, workspaceId) {
-    return join(runtimeRoot, "orchestrator", "workspaces", workspaceId, "config.json");
+export function orchestratorTenantConfigPath(runtimeRoot, tenantId) {
+    return join(runtimeRoot, "orchestrator", "tenants", tenantId, "config.json");
 }
-export async function syncWorkspaceToRuntime(configDir, workspaceConfig) {
+export async function syncTenantToRuntime(configDir, tenantConfig) {
     const runtimeRoot = resolveRuntimeRoot(configDir);
-    const configPath = orchestratorWorkspaceConfigPath(runtimeRoot, workspaceConfig.workspaceId);
+    const configPath = orchestratorTenantConfigPath(runtimeRoot, tenantConfig.tenantId);
     await mkdir(dirname(configPath), { recursive: true });
-    await writeFile(configPath, JSON.stringify(workspaceConfig, null, 2) + "\n");
+    await writeFile(configPath, JSON.stringify(tenantConfig, null, 2) + "\n");
+    // Copy tenant WORKFLOW.md to runtime if it exists
+    const workflowSrc = join(configDir, "tenants", tenantConfig.tenantId, "WORKFLOW.md");
+    const workflowDst = join(dirname(configPath), "WORKFLOW.md");
+    try {
+        await copyFile(workflowSrc, workflowDst);
+    }
+    catch (error) {
+        // ENOENT is expected for tenants created before WORKFLOW.md scaffolding
+        if (!(error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT")) {
+            throw error;
+        }
+    }
     return runtimeRoot;
 }

package/dist/skills/skill-writer.d.ts

@@ -0,0 +1,14 @@
+import type { SkillTemplate, SkillTemplateContext } from "./types.js";
+export declare function resolveSkillsDir(repoRoot: string, runtime: string): string | null;
+export declare function writeSkillFile(skillsDir: string, template: SkillTemplate, context: SkillTemplateContext, options?: {
+    overwrite?: boolean;
+}): Promise<{
+    written: boolean;
+    path: string;
+}>;
+export declare function writeAllSkills(repoRoot: string, runtime: string, templates: SkillTemplate[], context: SkillTemplateContext, options?: {
+    overwrite?: boolean;
+}): Promise<{
+    written: string[];
+    skipped: string[];
+}>;

package/dist/skills/skill-writer.js

@@ -0,0 +1,62 @@
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+import { join } from "node:path";
+function normalizeRuntimeForSkills(runtime) {
+    if (runtime === "claude-code" || runtime.includes("claude-code")) {
+        return "claude-code";
+    }
+    if (runtime === "codex" || runtime.includes("codex")) {
+        return "codex";
+    }
+    return null;
+}
+export function resolveSkillsDir(repoRoot, runtime) {
+    const normalizedRuntime = normalizeRuntimeForSkills(runtime);
+    if (normalizedRuntime === "claude-code") {
+        return join(repoRoot, ".claude", "skills");
+    }
+    if (normalizedRuntime === "codex") {
+        return join(repoRoot, ".codex", "skills");
+    }
+    return null;
+}
+export async function writeSkillFile(skillsDir, template, context, options) {
+    const skillDir = join(skillsDir, template.name);
+    const filePath = join(skillDir, template.fileName);
+    if (!options?.overwrite) {
+        try {
+            await readFile(filePath, "utf8");
+            return { written: false, path: filePath };
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    await mkdir(skillDir, { recursive: true });
+    const content = template.generate(context);
+    const temporaryPath = `${filePath}.tmp`;
+    await writeFile(temporaryPath, content, "utf8");
+    const { rename } = await import("node:fs/promises");
+    await rename(temporaryPath, filePath);
+    return { written: true, path: filePath };
+}
+export async function writeAllSkills(repoRoot, runtime, templates, context, options) {
+    const skillsDir = resolveSkillsDir(repoRoot, runtime);
+    if (!skillsDir) {
+        return { written: [], skipped: [] };
+    }
+    const written = [];
+    const skipped = [];
+    for (const template of templates) {
+        const result = await writeSkillFile(skillsDir, template, context, options);
+        if (result.written) {
+            written.push(result.path);
+        }
+        else {
+            skipped.push(result.path);
+        }
+    }
+    return { written, skipped };
+}

package/dist/skills/templates/commit.d.ts

@@ -0,0 +1,2 @@
+import type { SkillTemplateContext } from "../types.js";
+export declare function generateCommitSkill(_ctx: SkillTemplateContext): string;