@niujiajie/freespec 0.0.0-stage → 1.15.0

package/dist/core/shared-skill-target.js

@@ -0,0 +1,239 @@
+import path from 'path';
+import * as fs from 'fs';
+import { AI_TOOLS, OPENSPEC_SKILL_NAMES } from './config.js';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { resolveCommandSurfaceCapability } from './command-surface.js';
+import { DISK_VIEW } from './file-view.js';
+const TARGET_MARKER = '.freespec-target';
+/** Returns the ownership-marker path for one shared skills root. */
+function markerPath(projectPath, skillsDir) {
+    return path.join(projectPath, skillsDir, 'skills', TARGET_MARKER);
+}
+/** Reads a valid-looking marker value without letting linked roots escape. */
+export function readSharedSkillTarget(projectPath, skillsDir, view = DISK_VIEW) {
+    try {
+        const target = markerPath(projectPath, skillsDir);
+        FileSystemUtils.assertProjectArtifactPath(projectPath, target);
+        return view.read(target).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether a tool still has an allowlisted managed skill under an old root. */
+export function hasLegacySkills(projectPath, tool, view = DISK_VIEW) {
+    return (tool.legacySkillsDirs ?? []).some((root) => {
+        const skillsDir = path.join(projectPath, root, 'skills');
+        return OPENSPEC_SKILL_NAMES.some((skillName) => {
+            try {
+                const skillFile = path.join(skillsDir, skillName, 'SKILL.md');
+                FileSystemUtils.assertProjectArtifactPath(projectPath, skillFile);
+                return view.exists(skillFile);
+            }
+            catch {
+                return false;
+            }
+        });
+    });
+}
+/**
+ * Infers pre-marker ownership from generated invocation syntax. This preserves
+ * both existing generic `.agents` trees and Codex trees users moved manually.
+ */
+function inferSharedSkillTarget(projectPath, skillsDir, view = DISK_VIEW) {
+    let foundGenericReference = false;
+    for (const skillName of OPENSPEC_SKILL_NAMES) {
+        const skillFile = path.join(projectPath, skillsDir, 'skills', skillName, 'SKILL.md');
+        try {
+            FileSystemUtils.assertProjectArtifactPath(projectPath, skillFile);
+            const content = view.read(skillFile);
+            if (content.includes('$freespec-'))
+                return 'codex';
+            if (content.includes('/freespec-'))
+                foundGenericReference = true;
+        }
+        catch {
+            // Missing, unreadable, or out-of-project files provide no ownership signal.
+        }
+    }
+    return foundGenericReference ? 'agents' : undefined;
+}
+/** Whether the canonical shared root already contains a FreeSpec skill. */
+function hasCurrentSkills(projectPath, skillsDir, view = DISK_VIEW) {
+    return OPENSPEC_SKILL_NAMES.some((skillName) => {
+        const skillFile = path.join(projectPath, skillsDir, 'skills', skillName, 'SKILL.md');
+        try {
+            FileSystemUtils.assertProjectArtifactPath(projectPath, skillFile);
+            return view.exists(skillFile);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Chooses the one selected tool that may render each physical skills root.
+ * Command files are not part of this arbitration: tools that share a skills
+ * root can still write their own command surface elsewhere under that root.
+ *
+ * Existing compatible owners win. On a new root, prefer a skills-native
+ * renderer over an adapter-backed renderer because its references remain
+ * usable by every consumer of the shared tree. Codex is the best fresh owner
+ * because its renderer includes both Codex and generic skill invocation forms.
+ */
+export function resolveSharedSkillWriters(projectPath, tools, view = DISK_VIEW) {
+    const byRoot = new Map();
+    const writers = new Set();
+    for (const tool of tools) {
+        if (!tool.skillsDir)
+            continue;
+        const group = byRoot.get(tool.skillsDir) ?? [];
+        group.push(tool);
+        byRoot.set(tool.skillsDir, group);
+    }
+    for (const [root, unsortedGroup] of byRoot) {
+        const group = [...unsortedGroup].sort((left, right) => AI_TOOLS.indexOf(left) - AI_TOOLS.indexOf(right));
+        if (group.length === 1) {
+            writers.add(group[0].value);
+            continue;
+        }
+        const skillsNative = group.filter((tool) => resolveCommandSurfaceCapability(tool.value) !== 'adapter-backed');
+        const preferredPool = skillsNative.length > 0 ? skillsNative : group;
+        const marked = readSharedSkillTarget(projectPath, root, view);
+        const inferred = inferSharedSkillTarget(projectPath, root, view);
+        const owner = preferredPool.find((tool) => tool.value === marked) ??
+            preferredPool.find((tool) => tool.value === inferred) ??
+            (hasCurrentSkills(projectPath, root, view)
+                ? preferredPool.find((tool) => tool.value === 'agents')
+                : undefined) ??
+            preferredPool.find((tool) => tool.value === 'codex') ??
+            preferredPool[0];
+        writers.add(owner.value);
+    }
+    return writers;
+}
+/**
+ * A shared skill root can only hold one rendered variant of each skill.
+ * Keep the writer recorded so later updates do not infer every tool that
+ * happens to use the same directory.
+ */
+export function reconcileSharedSkillTargets(projectPath, tools, view = DISK_VIEW) {
+    const byRoot = new Map();
+    for (const tool of tools) {
+        if (!tool.skillsDir)
+            continue;
+        const group = byRoot.get(tool.skillsDir) ?? [];
+        group.push(tool);
+        byRoot.set(tool.skillsDir, group);
+    }
+    const reconciled = [];
+    for (const group of byRoot.values()) {
+        if (group.length === 1) {
+            reconciled.push(group[0]);
+            continue;
+        }
+        const root = group[0].skillsDir;
+        const marked = readSharedSkillTarget(projectPath, root, view);
+        const markedTool = group.find((tool) => tool.value === marked);
+        if (markedTool) {
+            reconciled.push(markedTool);
+            continue;
+        }
+        const inferred = inferSharedSkillTarget(projectPath, root, view);
+        const legacyCodex = group.find((tool) => tool.value === 'codex' && hasLegacySkills(projectPath, tool, view));
+        if (inferred === 'agents' && legacyCodex) {
+            // Before ownership markers existed, selecting both targets produced a
+            // generic canonical tree plus a Codex-only legacy tree. Codex now emits
+            // a dual-syntax canonical tree, so it can safely consolidate that state.
+            reconciled.push(legacyCodex);
+            continue;
+        }
+        const inferredTool = group.find((tool) => tool.value === inferred);
+        if (inferredTool) {
+            reconciled.push(inferredTool);
+            continue;
+        }
+        // An unmarked canonical tree predates Codex's move into `.agents`; keep
+        // that established agents target instead of overwriting it from `.codex`.
+        if (hasCurrentSkills(projectPath, root, view)) {
+            reconciled.push(group.find((tool) => tool.value === 'agents') ?? group[0]);
+            continue;
+        }
+        const legacyTool = group.find((tool) => hasLegacySkills(projectPath, tool, view));
+        if (legacyTool) {
+            reconciled.push(legacyTool);
+            continue;
+        }
+        // `.agents` existed as the vendor-neutral target before Codex adopted it.
+        // Unmarked trees therefore retain that established meaning.
+        reconciled.push(group.find((tool) => tool.value === 'agents') ?? group[0]);
+    }
+    return reconciled;
+}
+/**
+ * Returns whether a tool is the active writer for its physical skills root.
+ * Non-shared roots are always active.
+ */
+export function isSharedSkillTargetActive(projectPath, toolId, view = DISK_VIEW) {
+    const tool = AI_TOOLS.find((candidate) => candidate.value === toolId);
+    if (!tool?.skillsDir)
+        return false;
+    const sharingRoot = AI_TOOLS.filter((candidate) => candidate.skillsDir === tool.skillsDir);
+    if (sharingRoot.length < 2)
+        return true;
+    return reconcileSharedSkillTargets(projectPath, sharingRoot, view)
+        .some((candidate) => candidate.value === toolId);
+}
+/**
+ * The tool that already owns `toolId`'s shared skills root, when a DIFFERENT
+ * one does. Returns the owner's tool id only when the root already carries an
+ * ownership signal (a marker or generated skills) AND reconciliation resolves
+ * it to another tool. An empty or unclaimed root returns undefined, so a
+ * genuine first-time legacy upgrade — e.g. a Codex-only user with no `.agents`
+ * yet — is never reported as owned.
+ */
+export function sharedSkillRootOwner(projectPath, toolId) {
+    const tool = AI_TOOLS.find((candidate) => candidate.value === toolId);
+    if (!tool?.skillsDir)
+        return undefined;
+    const sharingRoot = AI_TOOLS.filter((candidate) => candidate.skillsDir === tool.skillsDir);
+    if (sharingRoot.length < 2)
+        return undefined;
+    const hasOwnerSignal = readSharedSkillTarget(projectPath, tool.skillsDir) !== undefined ||
+        hasCurrentSkills(projectPath, tool.skillsDir);
+    if (!hasOwnerSignal)
+        return undefined;
+    const owner = reconcileSharedSkillTargets(projectPath, sharingRoot)[0]?.value;
+    return owner && owner !== toolId ? owner : undefined;
+}
+/**
+ * Whether generating `toolId` into its shared skills root would clobber a tree
+ * a DIFFERENT tool already owns — the guard the legacy-upgrade path uses before
+ * writing skills. See {@link sharedSkillRootOwner} for the ownership rules.
+ */
+export function sharedSkillRootOwnedByOther(projectPath, toolId) {
+    return sharedSkillRootOwner(projectPath, toolId) !== undefined;
+}
+/**
+ * Path of the owner marker for a tool's shared skills root, or null when the
+ * tool has no shared root to mark. Lets a caller write the marker itself —
+ * `update` routes it through its write seam so a dry run can list it.
+ */
+export function sharedSkillTargetMarkerPath(projectPath, toolId) {
+    const tool = AI_TOOLS.find((candidate) => candidate.value === toolId);
+    if (!tool?.skillsDir)
+        return null;
+    const sharingRoot = AI_TOOLS.filter((candidate) => candidate.skillsDir === tool.skillsDir);
+    if (sharingRoot.length < 2)
+        return null;
+    return markerPath(projectPath, tool.skillsDir);
+}
+export function writeSharedSkillTarget(projectPath, toolId) {
+    const target = sharedSkillTargetMarkerPath(projectPath, toolId);
+    if (!target)
+        return;
+    FileSystemUtils.assertProjectArtifactPath(projectPath, target);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, `${toolId}\n`, 'utf-8');
+}
+//# sourceMappingURL=shared-skill-target.js.map

package/dist/core/store/errors.d.ts

@@ -0,0 +1,20 @@
+export type StoreDiagnosticSeverity = 'error' | 'warning' | 'info';
+export interface StoreDiagnostic {
+    severity: StoreDiagnosticSeverity;
+    code: string;
+    message: string;
+    target?: string;
+    fix?: string;
+}
+export declare class StoreError extends Error {
+    readonly diagnostic: StoreDiagnostic;
+    constructor(message: string, code: string, options?: {
+        target?: string;
+        fix?: string;
+    });
+}
+export declare function makeStoreDiagnostic(severity: StoreDiagnosticSeverity, code: string, message: string, options?: {
+    target?: string;
+    fix?: string;
+}): StoreDiagnostic;
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/store/errors.js

@@ -0,0 +1,22 @@
+export class StoreError extends Error {
+    diagnostic;
+    constructor(message, code, options = {}) {
+        super(message);
+        this.name = 'StoreError';
+        this.diagnostic = {
+            severity: 'error',
+            code,
+            message,
+            ...options,
+        };
+    }
+}
+export function makeStoreDiagnostic(severity, code, message, options = {}) {
+    return {
+        severity,
+        code,
+        message,
+        ...options,
+    };
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/store/index.js

@@ -0,0 +1,2 @@
+export * from './errors.js';
+//# sourceMappingURL=index.js.map

package/dist/core/styles/palette.d.ts

@@ -0,0 +1,7 @@
+export declare const PALETTE: {
+    white: import("chalk").ChalkInstance;
+    lightGray: import("chalk").ChalkInstance;
+    midGray: import("chalk").ChalkInstance;
+    darkGray: import("chalk").ChalkInstance;
+};
+//# sourceMappingURL=palette.d.ts.map

package/dist/core/styles/palette.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+export const PALETTE = {
+    white: chalk.hex('#f4f4f4'),
+    lightGray: chalk.hex('#c8c8c8'),
+    midGray: chalk.hex('#8a8a8a'),
+    darkGray: chalk.hex('#4a4a4a')
+};
+//# sourceMappingURL=palette.js.map

package/dist/core/templates/optional-workflow.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Optional-Workflow Conditionals
+ *
+ * Not every workflow is installed. The `core` profile ships six of the twelve
+ * (`propose`, `explore`, `apply`, `update`, `sync`, `archive`), and a `custom`
+ * profile can ship any subset. A template that names `/freespec:continue` is
+ * therefore writing a dead reference for anyone whose profile omits it — the
+ * agent is told to hand off to a workflow that was never generated (#1734,
+ * umbrella #919).
+ *
+ * `command-references.ts` rewrites how a reference is spelled; this module
+ * decides whether it is emitted at all. Templates author both branches with
+ * `optionalWorkflow()`, and `resolveOptionalWorkflows()` picks one at
+ * generation time against the resolved workflow set, so the generated file
+ * states one path instead of asking the model to check availability at runtime.
+ */
+/**
+ * Authors a passage whose wording depends on whether `workflowId` is installed.
+ *
+ * Both branches must read correctly on their own: the generated file contains
+ * exactly one of them, with no trace of the other.
+ *
+ * @param workflowId - Workflow id as it appears in ALL_WORKFLOWS (e.g. 'continue')
+ * @param whenInstalled - Text to emit when the workflow is part of the profile
+ * @param whenMissing - Text to emit otherwise, typically a CLI fallback
+ *
+ * @example
+ * optionalWorkflow('continue', 'suggest `/freespec:continue`', 'run `freespec status`')
+ */
+export declare function optionalWorkflow(workflowId: string, whenInstalled: string, whenMissing: string): string;
+/**
+ * A passage that is dropped entirely when `workflowId` is not installed.
+ *
+ * Use for a line that only makes sense alongside the workflow it names — a
+ * command-reference table row, a bullet listing one workflow. When the
+ * conditional is the whole line, the line goes with it rather than leaving a
+ * blank one behind.
+ *
+ * @param workflowId - Workflow id as it appears in ALL_WORKFLOWS
+ * @param whenInstalled - Text to emit when the workflow is part of the profile
+ */
+export declare function onlyWithWorkflow(workflowId: string, whenInstalled: string): string;
+/**
+ * Resolves every `optionalWorkflow()` passage in `text` against the workflows
+ * that will actually be installed.
+ *
+ * Runs before the command-reference transformers, so a reference in a branch
+ * that was dropped never reaches them.
+ *
+ * @param text - Template body, possibly containing conditionals
+ * @param installedWorkflows - The resolved workflow set for this installation
+ * @returns The body with one branch of each conditional kept
+ * @throws If a malformed conditional leaves a marker in the output
+ */
+export declare function resolveOptionalWorkflows(text: string, installedWorkflows: ReadonlySet<string>): string;
+/**
+ * Fails loudly if `text` still carries a conditional marker.
+ *
+ * Called at the end of resolution to catch a malformed block, and again at the
+ * points that write a generated file — so a body that skipped resolution
+ * altogether (a generation path that bypassed getSkillTemplates /
+ * getCommandTemplates) throws instead of shipping literal markers to a user.
+ *
+ * @param text - Text about to be written, or just resolved
+ * @param reason - What went wrong, used as the message prefix
+ * @throws If any `[[freespec:...]]` marker remains
+ */
+export declare function assertWorkflowConditionalsResolved(text: string, reason: string): void;
+//# sourceMappingURL=optional-workflow.d.ts.map

package/dist/core/templates/optional-workflow.js

@@ -0,0 +1,140 @@
+/**
+ * Optional-Workflow Conditionals
+ *
+ * Not every workflow is installed. The `core` profile ships six of the twelve
+ * (`propose`, `explore`, `apply`, `update`, `sync`, `archive`), and a `custom`
+ * profile can ship any subset. A template that names `/freespec:continue` is
+ * therefore writing a dead reference for anyone whose profile omits it — the
+ * agent is told to hand off to a workflow that was never generated (#1734,
+ * umbrella #919).
+ *
+ * `command-references.ts` rewrites how a reference is spelled; this module
+ * decides whether it is emitted at all. Templates author both branches with
+ * `optionalWorkflow()`, and `resolveOptionalWorkflows()` picks one at
+ * generation time against the resolved workflow set, so the generated file
+ * states one path instead of asking the model to check availability at runtime.
+ */
+const OPEN = '[[freespec:if-workflow ';
+const OPEN_END = ']]';
+const ELSE = '[[freespec:else]]';
+const END = '[[freespec:end]]';
+/**
+ * A conditional that occupies a whole line on its own. Matched first so a
+ * branch that resolves to empty takes its line with it — otherwise dropping a
+ * table row or a bullet would leave a blank line behind, which markdown reads
+ * as the end of the table or list.
+ */
+const WHOLE_LINE_PATTERN = /^([ \t]*)\[\[freespec:if-workflow ([a-z-]+)\]\]([^\n]*?)\[\[freespec:else\]\]([^\n]*?)\[\[freespec:end\]\][ \t]*\r?\n/gm;
+const CONDITIONAL_PATTERN = /\[\[freespec:if-workflow ([a-z-]+)\]\]([\s\S]*?)\[\[freespec:else\]\]([\s\S]*?)\[\[freespec:end\]\]/g;
+/** Any leftover marker, used to fail loudly on malformed authoring. */
+const RESIDUAL_MARKER_PATTERN = /\[\[freespec:(if-workflow|else|end)/;
+/** A single well-formed marker, in any position. */
+const MARKER_PATTERN = /\[\[freespec:(?:if-workflow [a-z-]+|else|end)\]\]/g;
+/** Anything that opens like a marker, well-formed or not. */
+const MARKER_LIKE_PATTERN = /\[\[freespec:/;
+/**
+ * Rejects a malformed conditional before any branch is chosen.
+ *
+ * Checking after resolution is not enough: the unselected branch is discarded
+ * first, so a truncated block inside it would pass for one profile and throw
+ * for another — the exact profile-dependent behavior this module exists to
+ * remove. Authoring is either valid for every profile or valid for none.
+ *
+ * @param text - Template body as authored
+ * @throws If a marker is unrecognized, or the blocks are not a flat sequence
+ *         of if / else / end
+ */
+function assertConditionalsWellFormed(text) {
+    const kinds = [];
+    const withoutMarkers = text.replace(MARKER_PATTERN, (marker) => {
+        kinds.push(marker.startsWith(OPEN) ? 'if' : marker === ELSE ? 'else' : 'end');
+        return '';
+    });
+    const unrecognized = MARKER_LIKE_PATTERN.exec(withoutMarkers);
+    if (unrecognized) {
+        throw new Error(`Malformed optional-workflow conditional: unrecognized marker at '${withoutMarkers
+            .slice(unrecognized.index, unrecognized.index + 40)
+            .split('\n')[0]}'. Markers are [[freespec:if-workflow <id>]], [[freespec:else]] and [[freespec:end]].`);
+    }
+    for (let i = 0; i < kinds.length; i += 3) {
+        if (kinds[i] !== 'if' || kinds[i + 1] !== 'else' || kinds[i + 2] !== 'end') {
+            throw new Error('Malformed optional-workflow conditional: markers are out of order or a ' +
+                'block is incomplete. Each block needs the full [[freespec:if-workflow <id>]] ' +
+                '... [[freespec:else]] ... [[freespec:end]] form, and blocks cannot nest.');
+        }
+    }
+}
+/**
+ * Authors a passage whose wording depends on whether `workflowId` is installed.
+ *
+ * Both branches must read correctly on their own: the generated file contains
+ * exactly one of them, with no trace of the other.
+ *
+ * @param workflowId - Workflow id as it appears in ALL_WORKFLOWS (e.g. 'continue')
+ * @param whenInstalled - Text to emit when the workflow is part of the profile
+ * @param whenMissing - Text to emit otherwise, typically a CLI fallback
+ *
+ * @example
+ * optionalWorkflow('continue', 'suggest `/freespec:continue`', 'run `freespec status`')
+ */
+export function optionalWorkflow(workflowId, whenInstalled, whenMissing) {
+    return `${OPEN}${workflowId}${OPEN_END}${whenInstalled}${ELSE}${whenMissing}${END}`;
+}
+/**
+ * A passage that is dropped entirely when `workflowId` is not installed.
+ *
+ * Use for a line that only makes sense alongside the workflow it names — a
+ * command-reference table row, a bullet listing one workflow. When the
+ * conditional is the whole line, the line goes with it rather than leaving a
+ * blank one behind.
+ *
+ * @param workflowId - Workflow id as it appears in ALL_WORKFLOWS
+ * @param whenInstalled - Text to emit when the workflow is part of the profile
+ */
+export function onlyWithWorkflow(workflowId, whenInstalled) {
+    return optionalWorkflow(workflowId, whenInstalled, '');
+}
+/**
+ * Resolves every `optionalWorkflow()` passage in `text` against the workflows
+ * that will actually be installed.
+ *
+ * Runs before the command-reference transformers, so a reference in a branch
+ * that was dropped never reaches them.
+ *
+ * @param text - Template body, possibly containing conditionals
+ * @param installedWorkflows - The resolved workflow set for this installation
+ * @returns The body with one branch of each conditional kept
+ * @throws If a malformed conditional leaves a marker in the output
+ */
+export function resolveOptionalWorkflows(text, installedWorkflows) {
+    assertConditionalsWellFormed(text);
+    const wholeLinesResolved = text.replace(WHOLE_LINE_PATTERN, (_match, indent, workflowId, whenInstalled, whenMissing) => {
+        const chosen = installedWorkflows.has(workflowId) ? whenInstalled : whenMissing;
+        return chosen === '' ? '' : `${indent}${chosen}\n`;
+    });
+    const resolved = wholeLinesResolved.replace(CONDITIONAL_PATTERN, (_match, workflowId, whenInstalled, whenMissing) => installedWorkflows.has(workflowId) ? whenInstalled : whenMissing);
+    assertWorkflowConditionalsResolved(resolved, 'Malformed optional-workflow conditional');
+    return resolved;
+}
+/**
+ * Fails loudly if `text` still carries a conditional marker.
+ *
+ * Called at the end of resolution to catch a malformed block, and again at the
+ * points that write a generated file — so a body that skipped resolution
+ * altogether (a generation path that bypassed getSkillTemplates /
+ * getCommandTemplates) throws instead of shipping literal markers to a user.
+ *
+ * @param text - Text about to be written, or just resolved
+ * @param reason - What went wrong, used as the message prefix
+ * @throws If any `[[freespec:...]]` marker remains
+ */
+export function assertWorkflowConditionalsResolved(text, reason) {
+    const residual = RESIDUAL_MARKER_PATTERN.exec(text);
+    if (residual) {
+        throw new Error(`${reason}: '${residual[0]}' is unresolved. Optional-workflow blocks are ` +
+            'resolved by getSkillTemplates()/getCommandTemplates() against the installed ' +
+            'workflow set, and each needs the full [[freespec:if-workflow <id>]] ... ' +
+            '[[freespec:else]] ... [[freespec:end]] form.');
+    }
+}
+//# sourceMappingURL=optional-workflow.js.map

package/dist/core/templates/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Core template types for skills and slash commands.
+ */
+export interface SkillTemplate {
+    name: string;
+    description: string;
+    instructions: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+}
+export interface CommandTemplate {
+    name: string;
+    description: string;
+    category: string;
+    tags: string[];
+    content: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/templates/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core template types for skills and slash commands.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/templates/workflows/personal.d.ts

@@ -0,0 +1,22 @@
+import type { SkillTemplate, CommandTemplate } from '../types.js';
+export declare function getNewSkillTemplate(): SkillTemplate;
+export declare function getNewCommandTemplate(): CommandTemplate;
+export declare function getAskSkillTemplate(): SkillTemplate;
+export declare function getAskCommandTemplate(): CommandTemplate;
+export declare function getRequirementsSkillTemplate(): SkillTemplate;
+export declare function getRequirementsCommandTemplate(): CommandTemplate;
+export declare function getDesignSkillTemplate(): SkillTemplate;
+export declare function getDesignCommandTemplate(): CommandTemplate;
+export declare function getTasksSkillTemplate(): SkillTemplate;
+export declare function getTasksCommandTemplate(): CommandTemplate;
+export declare function getCasesSkillTemplate(): SkillTemplate;
+export declare function getCasesCommandTemplate(): CommandTemplate;
+export declare function getReviewDocsSkillTemplate(): SkillTemplate;
+export declare function getReviewDocsCommandTemplate(): CommandTemplate;
+export declare function getCheckSkillTemplate(): SkillTemplate;
+export declare function getCheckCommandTemplate(): CommandTemplate;
+export declare function getJavaImplSkillTemplate(): SkillTemplate;
+export declare function getJavaImplCommandTemplate(): CommandTemplate;
+export declare function getJavaReviewSkillTemplate(): SkillTemplate;
+export declare function getJavaReviewCommandTemplate(): CommandTemplate;
+//# sourceMappingURL=personal.d.ts.map