@rejot-dev/thalo 0.0.0

package/dist/commands/check.d.ts

@@ -0,0 +1,65 @@
+import { Workspace } from "../model/workspace.js";
+import { CheckConfig } from "../checker/check.js";
+
+//#region src/commands/check.d.ts
+
+/**
+ * Severity levels for diagnostics
+ */
+type DiagnosticSeverity = "error" | "warning" | "info";
+/**
+ * A single diagnostic (error, warning, or info) from the checker.
+ */
+interface DiagnosticInfo {
+  /** File path where the diagnostic occurred */
+  file: string;
+  /** 1-based line number */
+  line: number;
+  /** 1-based column number */
+  column: number;
+  /** End line (1-based) */
+  endLine: number;
+  /** End column (1-based) */
+  endColumn: number;
+  /** Severity level */
+  severity: DiagnosticSeverity;
+  /** Rule code (e.g., "unknown-entity", "missing-title") */
+  code: string;
+  /** Human-readable error message */
+  message: string;
+}
+/**
+ * Result of running the check command.
+ */
+interface CheckResult {
+  /** Number of files that were checked */
+  filesChecked: number;
+  /** Diagnostics grouped by file path */
+  diagnosticsByFile: Map<string, DiagnosticInfo[]>;
+  /** Total number of errors */
+  errorCount: number;
+  /** Total number of warnings */
+  warningCount: number;
+  /** Total number of info messages */
+  infoCount: number;
+}
+/**
+ * Options for running the check command.
+ */
+interface RunCheckOptions {
+  /** Checker configuration (rule overrides, etc.) */
+  config?: CheckConfig;
+  /** Minimum severity to include (default: "info") */
+  minSeverity?: DiagnosticSeverity;
+}
+/**
+ * Run the check command on a workspace.
+ *
+ * @param workspace - The workspace to check
+ * @param options - Check options
+ * @returns Structured check results
+ */
+declare function runCheck(workspace: Workspace, options?: RunCheckOptions): CheckResult;
+//#endregion
+export { CheckResult, DiagnosticInfo, DiagnosticSeverity, RunCheckOptions, runCheck };
+//# sourceMappingURL=check.d.ts.map

package/dist/commands/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","names":[],"sources":["../../src/commands/check.ts"],"sourcesContent":[],"mappings":";;;;;AAoBA;AAsBA;AAgBA;AAoCgB,KA/EJ,kBAAA,GA+EY,OAAA,GAAA,SAAA,GAAA,MAAA;;;;AAAkE,UA1EzE,cAAA,CA0EyE;;;;;;;;;;;;YA9D9E;;;;;;;;;UAUK,WAAA;;;;qBAII,YAAY;;;;;;;;;;;UAYhB,eAAA;;WAEN;;gBAEK;;;;;;;;;iBAgCA,QAAA,YAAoB,qBAAoB,kBAAuB"}

package/dist/commands/check.js

@@ -0,0 +1,61 @@
+import { check } from "../checker/check.js";
+
+//#region src/commands/check.ts
+const SEVERITY_ORDER = {
+	error: 0,
+	warning: 1,
+	info: 2
+};
+/**
+* Convert a diagnostic to DiagnosticInfo.
+*/
+function toDiagnosticInfo(diagnostic) {
+	return {
+		file: diagnostic.file,
+		line: diagnostic.location.startPosition.row + 1,
+		column: diagnostic.location.startPosition.column + 1,
+		endLine: diagnostic.location.endPosition.row + 1,
+		endColumn: diagnostic.location.endPosition.column + 1,
+		severity: diagnostic.severity,
+		code: diagnostic.code,
+		message: diagnostic.message
+	};
+}
+/**
+* Run the check command on a workspace.
+*
+* @param workspace - The workspace to check
+* @param options - Check options
+* @returns Structured check results
+*/
+function runCheck(workspace, options = {}) {
+	const { config = {}, minSeverity = "info" } = options;
+	const diagnostics = check(workspace, config);
+	const minSeverityOrder = SEVERITY_ORDER[minSeverity];
+	const filteredDiagnostics = diagnostics.filter((d) => SEVERITY_ORDER[d.severity] <= minSeverityOrder);
+	filteredDiagnostics.sort((a, b) => {
+		if (a.file !== b.file) return a.file.localeCompare(b.file);
+		if (a.location.startPosition.row !== b.location.startPosition.row) return a.location.startPosition.row - b.location.startPosition.row;
+		return a.location.startPosition.column - b.location.startPosition.column;
+	});
+	const diagnosticsByFile = /* @__PURE__ */ new Map();
+	for (const d of filteredDiagnostics) {
+		const existing = diagnosticsByFile.get(d.file) || [];
+		existing.push(toDiagnosticInfo(d));
+		diagnosticsByFile.set(d.file, existing);
+	}
+	const errorCount = filteredDiagnostics.filter((d) => d.severity === "error").length;
+	const warningCount = filteredDiagnostics.filter((d) => d.severity === "warning").length;
+	const infoCount = filteredDiagnostics.filter((d) => d.severity === "info").length;
+	return {
+		filesChecked: workspace.files().length,
+		diagnosticsByFile,
+		errorCount,
+		warningCount,
+		infoCount
+	};
+}
+
+//#endregion
+export { runCheck };
+//# sourceMappingURL=check.js.map

package/dist/commands/check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.js","names":["SEVERITY_ORDER: Record<DiagnosticSeverity, number>"],"sources":["../../src/commands/check.ts"],"sourcesContent":["/**\n * Check command - runs the checker on a workspace and returns structured results.\n */\n\nimport type { Workspace } from \"../model/workspace.js\";\nimport { check } from \"../checker/check.js\";\nimport type { CheckConfig, Diagnostic } from \"../checker/check.js\";\n\n// ===================\n// Types\n// ===================\n\n/**\n * Severity levels for diagnostics\n */\nexport type DiagnosticSeverity = \"error\" | \"warning\" | \"info\";\n\n/**\n * A single diagnostic (error, warning, or info) from the checker.\n */\nexport interface DiagnosticInfo {\n  /** File path where the diagnostic occurred */\n  file: string;\n  /** 1-based line number */\n  line: number;\n  /** 1-based column number */\n  column: number;\n  /** End line (1-based) */\n  endLine: number;\n  /** End column (1-based) */\n  endColumn: number;\n  /** Severity level */\n  severity: DiagnosticSeverity;\n  /** Rule code (e.g., \"unknown-entity\", \"missing-title\") */\n  code: string;\n  /** Human-readable error message */\n  message: string;\n}\n\n/**\n * Result of running the check command.\n */\nexport interface CheckResult {\n  /** Number of files that were checked */\n  filesChecked: number;\n  /** Diagnostics grouped by file path */\n  diagnosticsByFile: Map<string, DiagnosticInfo[]>;\n  /** Total number of errors */\n  errorCount: number;\n  /** Total number of warnings */\n  warningCount: number;\n  /** Total number of info messages */\n  infoCount: number;\n}\n\n/**\n * Options for running the check command.\n */\nexport interface RunCheckOptions {\n  /** Checker configuration (rule overrides, etc.) */\n  config?: CheckConfig;\n  /** Minimum severity to include (default: \"info\") */\n  minSeverity?: DiagnosticSeverity;\n}\n\nconst SEVERITY_ORDER: Record<DiagnosticSeverity, number> = {\n  error: 0,\n  warning: 1,\n  info: 2,\n};\n\n/**\n * Convert a diagnostic to DiagnosticInfo.\n */\nfunction toDiagnosticInfo(diagnostic: Diagnostic): DiagnosticInfo {\n  return {\n    file: diagnostic.file,\n    line: diagnostic.location.startPosition.row + 1,\n    column: diagnostic.location.startPosition.column + 1,\n    endLine: diagnostic.location.endPosition.row + 1,\n    endColumn: diagnostic.location.endPosition.column + 1,\n    severity: diagnostic.severity as DiagnosticSeverity,\n    code: diagnostic.code,\n    message: diagnostic.message,\n  };\n}\n\n/**\n * Run the check command on a workspace.\n *\n * @param workspace - The workspace to check\n * @param options - Check options\n * @returns Structured check results\n */\nexport function runCheck(workspace: Workspace, options: RunCheckOptions = {}): CheckResult {\n  const { config = {}, minSeverity = \"info\" } = options;\n\n  // Run the checker\n  const diagnostics = check(workspace, config);\n\n  // Filter by minimum severity\n  const minSeverityOrder = SEVERITY_ORDER[minSeverity];\n  const filteredDiagnostics = diagnostics.filter(\n    (d) => SEVERITY_ORDER[d.severity as DiagnosticSeverity] <= minSeverityOrder,\n  );\n\n  // Sort diagnostics by file, then position\n  filteredDiagnostics.sort((a, b) => {\n    if (a.file !== b.file) {\n      return a.file.localeCompare(b.file);\n    }\n    if (a.location.startPosition.row !== b.location.startPosition.row) {\n      return a.location.startPosition.row - b.location.startPosition.row;\n    }\n    return a.location.startPosition.column - b.location.startPosition.column;\n  });\n\n  // Group by file\n  const diagnosticsByFile = new Map<string, DiagnosticInfo[]>();\n  for (const d of filteredDiagnostics) {\n    const existing = diagnosticsByFile.get(d.file) || [];\n    existing.push(toDiagnosticInfo(d));\n    diagnosticsByFile.set(d.file, existing);\n  }\n\n  // Count by severity\n  const errorCount = filteredDiagnostics.filter((d) => d.severity === \"error\").length;\n  const warningCount = filteredDiagnostics.filter((d) => d.severity === \"warning\").length;\n  const infoCount = filteredDiagnostics.filter((d) => d.severity === \"info\").length;\n\n  return {\n    filesChecked: workspace.files().length,\n    diagnosticsByFile,\n    errorCount,\n    warningCount,\n    infoCount,\n  };\n}\n"],"mappings":";;;AAiEA,MAAMA,iBAAqD;CACzD,OAAO;CACP,SAAS;CACT,MAAM;CACP;;;;AAKD,SAAS,iBAAiB,YAAwC;AAChE,QAAO;EACL,MAAM,WAAW;EACjB,MAAM,WAAW,SAAS,cAAc,MAAM;EAC9C,QAAQ,WAAW,SAAS,cAAc,SAAS;EACnD,SAAS,WAAW,SAAS,YAAY,MAAM;EAC/C,WAAW,WAAW,SAAS,YAAY,SAAS;EACpD,UAAU,WAAW;EACrB,MAAM,WAAW;EACjB,SAAS,WAAW;EACrB;;;;;;;;;AAUH,SAAgB,SAAS,WAAsB,UAA2B,EAAE,EAAe;CACzF,MAAM,EAAE,SAAS,EAAE,EAAE,cAAc,WAAW;CAG9C,MAAM,cAAc,MAAM,WAAW,OAAO;CAG5C,MAAM,mBAAmB,eAAe;CACxC,MAAM,sBAAsB,YAAY,QACrC,MAAM,eAAe,EAAE,aAAmC,iBAC5D;AAGD,qBAAoB,MAAM,GAAG,MAAM;AACjC,MAAI,EAAE,SAAS,EAAE,KACf,QAAO,EAAE,KAAK,cAAc,EAAE,KAAK;AAErC,MAAI,EAAE,SAAS,cAAc,QAAQ,EAAE,SAAS,cAAc,IAC5D,QAAO,EAAE,SAAS,cAAc,MAAM,EAAE,SAAS,cAAc;AAEjE,SAAO,EAAE,SAAS,cAAc,SAAS,EAAE,SAAS,cAAc;GAClE;CAGF,MAAM,oCAAoB,IAAI,KAA+B;AAC7D,MAAK,MAAM,KAAK,qBAAqB;EACnC,MAAM,WAAW,kBAAkB,IAAI,EAAE,KAAK,IAAI,EAAE;AACpD,WAAS,KAAK,iBAAiB,EAAE,CAAC;AAClC,oBAAkB,IAAI,EAAE,MAAM,SAAS;;CAIzC,MAAM,aAAa,oBAAoB,QAAQ,MAAM,EAAE,aAAa,QAAQ,CAAC;CAC7E,MAAM,eAAe,oBAAoB,QAAQ,MAAM,EAAE,aAAa,UAAU,CAAC;CACjF,MAAM,YAAY,oBAAoB,QAAQ,MAAM,EAAE,aAAa,OAAO,CAAC;AAE3E,QAAO;EACL,cAAc,UAAU,OAAO,CAAC;EAChC;EACA;EACA;EACA;EACD"}

package/dist/commands/format.d.ts

@@ -0,0 +1,90 @@
+import { Workspace } from "../model/workspace.js";
+
+//#region src/commands/format.d.ts
+
+/**
+ * A syntax error found during parsing.
+ */
+interface SyntaxErrorInfo {
+  /** File path where the error occurred */
+  file: string;
+  /** 1-based line number */
+  line: number;
+  /** 1-based column number */
+  column: number;
+  /** Human-readable error message */
+  message: string;
+  /** Error code (e.g., "syntax-parse_error") */
+  code: string;
+}
+/**
+ * Result of formatting a single file.
+ */
+interface FormatFileResult {
+  /** The file path */
+  file: string;
+  /** The formatted content (or original if unchanged/error) */
+  formatted: string;
+  /** Whether the content changed after formatting */
+  isChanged: boolean;
+  /** Whether the file has syntax errors (formatting skipped) */
+  hasSyntaxErrors: boolean;
+  /** Syntax errors found in the file (if any) */
+  syntaxErrors: SyntaxErrorInfo[];
+}
+/**
+ * Result of running the format command.
+ */
+interface FormatResult {
+  /** Number of files that were processed */
+  filesProcessed: number;
+  /** Results for each file */
+  fileResults: FormatFileResult[];
+  /** Number of files that were changed/need changes */
+  changedCount: number;
+  /** Number of files with syntax errors */
+  syntaxErrorCount: number;
+  /** Total number of syntax errors across all files */
+  totalSyntaxErrors: number;
+}
+/**
+ * A formatter function that formats source code.
+ */
+type Formatter = (source: string, filepath: string) => Promise<string>;
+/**
+ * Input for formatting a single file.
+ */
+interface FormatFileInput {
+  /** The file path */
+  file: string;
+  /** The file content */
+  content: string;
+}
+/**
+ * Options for running the format command.
+ */
+interface RunFormatOptions {
+  /** Custom formatter function (e.g., prettier) */
+  formatter: Formatter;
+}
+/**
+ * Format a single file, checking for syntax errors first.
+ *
+ * @param workspace - The workspace to use for syntax checking
+ * @param input - The file input (path and content)
+ * @param formatter - The formatter function to apply
+ * @returns The format result for this file
+ */
+declare function formatFile(workspace: Workspace, input: FormatFileInput, formatter: Formatter): Promise<FormatFileResult>;
+/**
+ * Run the format command on multiple files.
+ *
+ * @param workspace - The workspace to use for syntax checking
+ * @param files - The files to format (path and content)
+ * @param options - Format options including the formatter function
+ * @returns Structured format results
+ */
+declare function runFormat(workspace: Workspace, files: FormatFileInput[], options: RunFormatOptions): Promise<FormatResult>;
+//#endregion
+export { FormatFileInput, FormatFileResult, FormatResult, Formatter, RunFormatOptions, SyntaxErrorInfo, formatFile, runFormat };
+//# sourceMappingURL=format.d.ts.map

package/dist/commands/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","names":[],"sources":["../../src/commands/format.ts"],"sourcesContent":[],"mappings":";;;;AA6BA;AAgBA;AAgBA;AAKiB,UArDA,eAAA,CAqDe;EAUf;EAoDK,IAAA,EAAA,MAAA;EACT;EACJ,IAAA,EAAA,MAAA;EACI;EACF,MAAA,EAAA,MAAA;EAAR;EAAO,OAAA,EAAA,MAAA;EAoCY;EACT,IAAA,EAAA,MAAA;;;;;AAGH,UA/IO,gBAAA,CA+IP;;;;;;;;;;gBArIM;;;;;UAMC,YAAA;;;;eAIF;;;;;;;;;;;KAYH,SAAA,yCAAkD;;;;UAK7C,eAAA;;;;;;;;;UAUA,gBAAA;;aAEJ;;;;;;;;;;iBAkDS,UAAA,YACT,kBACJ,4BACI,YACV,QAAQ;;;;;;;;;iBAoCW,SAAA,YACT,kBACJ,4BACE,mBACR,QAAQ"}

package/dist/commands/format.js

@@ -0,0 +1,80 @@
+//#region src/commands/format.ts
+/**
+* Check a file for syntax errors using the thalo parser.
+* Returns syntax errors without running semantic analysis or rules.
+*/
+function collectSyntaxErrors(workspace, file, content) {
+	const errors = [];
+	workspace.addDocument(content, { filename: file });
+	try {
+		const model = workspace.getModel(file);
+		if (!model) return errors;
+		for (const error of model.ast.syntaxErrors) errors.push({
+			file,
+			line: error.location.startPosition.row + 1,
+			column: error.location.startPosition.column + 1,
+			message: error.message,
+			code: `syntax-${error.code}`
+		});
+		return errors;
+	} finally {
+		workspace.removeDocument(file);
+	}
+}
+/**
+* Format a single file, checking for syntax errors first.
+*
+* @param workspace - The workspace to use for syntax checking
+* @param input - The file input (path and content)
+* @param formatter - The formatter function to apply
+* @returns The format result for this file
+*/
+async function formatFile(workspace, input, formatter) {
+	const { file, content } = input;
+	const syntaxErrors = collectSyntaxErrors(workspace, file, content);
+	if (syntaxErrors.length > 0) return {
+		file,
+		formatted: content,
+		isChanged: false,
+		hasSyntaxErrors: true,
+		syntaxErrors
+	};
+	const formatted = await formatter(content, file);
+	return {
+		file,
+		formatted,
+		isChanged: content !== formatted,
+		hasSyntaxErrors: false,
+		syntaxErrors: []
+	};
+}
+/**
+* Run the format command on multiple files.
+*
+* @param workspace - The workspace to use for syntax checking
+* @param files - The files to format (path and content)
+* @param options - Format options including the formatter function
+* @returns Structured format results
+*/
+async function runFormat(workspace, files, options) {
+	const { formatter } = options;
+	const fileResults = [];
+	for (const input of files) {
+		const result = await formatFile(workspace, input, formatter);
+		fileResults.push(result);
+	}
+	const changedCount = fileResults.filter((r) => r.isChanged).length;
+	const syntaxErrorCount = fileResults.filter((r) => r.hasSyntaxErrors).length;
+	const totalSyntaxErrors = fileResults.reduce((sum, r) => sum + r.syntaxErrors.length, 0);
+	return {
+		filesProcessed: files.length,
+		fileResults,
+		changedCount,
+		syntaxErrorCount,
+		totalSyntaxErrors
+	};
+}
+
+//#endregion
+export { formatFile, runFormat };
+//# sourceMappingURL=format.js.map

package/dist/commands/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","names":["errors: SyntaxErrorInfo[]","fileResults: FormatFileResult[]"],"sources":["../../src/commands/format.ts"],"sourcesContent":["/**\n * Format command - checks syntax and formats files, returning structured results.\n */\n\nimport type { Workspace } from \"../model/workspace.js\";\n\n// ===================\n// Types\n// ===================\n\n/**\n * A syntax error found during parsing.\n */\nexport interface SyntaxErrorInfo {\n  /** File path where the error occurred */\n  file: string;\n  /** 1-based line number */\n  line: number;\n  /** 1-based column number */\n  column: number;\n  /** Human-readable error message */\n  message: string;\n  /** Error code (e.g., \"syntax-parse_error\") */\n  code: string;\n}\n\n/**\n * Result of formatting a single file.\n */\nexport interface FormatFileResult {\n  /** The file path */\n  file: string;\n  /** The formatted content (or original if unchanged/error) */\n  formatted: string;\n  /** Whether the content changed after formatting */\n  isChanged: boolean;\n  /** Whether the file has syntax errors (formatting skipped) */\n  hasSyntaxErrors: boolean;\n  /** Syntax errors found in the file (if any) */\n  syntaxErrors: SyntaxErrorInfo[];\n}\n\n/**\n * Result of running the format command.\n */\nexport interface FormatResult {\n  /** Number of files that were processed */\n  filesProcessed: number;\n  /** Results for each file */\n  fileResults: FormatFileResult[];\n  /** Number of files that were changed/need changes */\n  changedCount: number;\n  /** Number of files with syntax errors */\n  syntaxErrorCount: number;\n  /** Total number of syntax errors across all files */\n  totalSyntaxErrors: number;\n}\n\n/**\n * A formatter function that formats source code.\n */\nexport type Formatter = (source: string, filepath: string) => Promise<string>;\n\n/**\n * Input for formatting a single file.\n */\nexport interface FormatFileInput {\n  /** The file path */\n  file: string;\n  /** The file content */\n  content: string;\n}\n\n/**\n * Options for running the format command.\n */\nexport interface RunFormatOptions {\n  /** Custom formatter function (e.g., prettier) */\n  formatter: Formatter;\n}\n\n// ===================\n// Core Logic\n// ===================\n\n/**\n * Check a file for syntax errors using the thalo parser.\n * Returns syntax errors without running semantic analysis or rules.\n */\nfunction collectSyntaxErrors(\n  workspace: Workspace,\n  file: string,\n  content: string,\n): SyntaxErrorInfo[] {\n  const errors: SyntaxErrorInfo[] = [];\n\n  workspace.addDocument(content, { filename: file });\n  try {\n    const model = workspace.getModel(file);\n    if (!model) {\n      return errors;\n    }\n\n    // Collect root-level syntax errors\n    for (const error of model.ast.syntaxErrors) {\n      errors.push({\n        file,\n        line: error.location.startPosition.row + 1,\n        column: error.location.startPosition.column + 1,\n        message: error.message,\n        code: `syntax-${error.code}`,\n      });\n    }\n\n    return errors;\n  } finally {\n    workspace.removeDocument(file);\n  }\n}\n\n/**\n * Format a single file, checking for syntax errors first.\n *\n * @param workspace - The workspace to use for syntax checking\n * @param input - The file input (path and content)\n * @param formatter - The formatter function to apply\n * @returns The format result for this file\n */\nexport async function formatFile(\n  workspace: Workspace,\n  input: FormatFileInput,\n  formatter: Formatter,\n): Promise<FormatFileResult> {\n  const { file, content } = input;\n\n  // Check for syntax errors first\n  const syntaxErrors = collectSyntaxErrors(workspace, file, content);\n  if (syntaxErrors.length > 0) {\n    // Return unchanged content - don't format files with syntax errors\n    return {\n      file,\n      formatted: content,\n      isChanged: false,\n      hasSyntaxErrors: true,\n      syntaxErrors,\n    };\n  }\n\n  // Format the file\n  const formatted = await formatter(content, file);\n\n  return {\n    file,\n    formatted,\n    isChanged: content !== formatted,\n    hasSyntaxErrors: false,\n    syntaxErrors: [],\n  };\n}\n\n/**\n * Run the format command on multiple files.\n *\n * @param workspace - The workspace to use for syntax checking\n * @param files - The files to format (path and content)\n * @param options - Format options including the formatter function\n * @returns Structured format results\n */\nexport async function runFormat(\n  workspace: Workspace,\n  files: FormatFileInput[],\n  options: RunFormatOptions,\n): Promise<FormatResult> {\n  const { formatter } = options;\n\n  const fileResults: FormatFileResult[] = [];\n\n  // Process files sequentially to avoid workspace conflicts\n  // (workspace.addDocument/removeDocument is not concurrent-safe)\n  for (const input of files) {\n    const result = await formatFile(workspace, input, formatter);\n    fileResults.push(result);\n  }\n\n  // Calculate summary statistics\n  const changedCount = fileResults.filter((r) => r.isChanged).length;\n  const syntaxErrorCount = fileResults.filter((r) => r.hasSyntaxErrors).length;\n  const totalSyntaxErrors = fileResults.reduce((sum, r) => sum + r.syntaxErrors.length, 0);\n\n  return {\n    filesProcessed: files.length,\n    fileResults,\n    changedCount,\n    syntaxErrorCount,\n    totalSyntaxErrors,\n  };\n}\n"],"mappings":";;;;;AAyFA,SAAS,oBACP,WACA,MACA,SACmB;CACnB,MAAMA,SAA4B,EAAE;AAEpC,WAAU,YAAY,SAAS,EAAE,UAAU,MAAM,CAAC;AAClD,KAAI;EACF,MAAM,QAAQ,UAAU,SAAS,KAAK;AACtC,MAAI,CAAC,MACH,QAAO;AAIT,OAAK,MAAM,SAAS,MAAM,IAAI,aAC5B,QAAO,KAAK;GACV;GACA,MAAM,MAAM,SAAS,cAAc,MAAM;GACzC,QAAQ,MAAM,SAAS,cAAc,SAAS;GAC9C,SAAS,MAAM;GACf,MAAM,UAAU,MAAM;GACvB,CAAC;AAGJ,SAAO;WACC;AACR,YAAU,eAAe,KAAK;;;;;;;;;;;AAYlC,eAAsB,WACpB,WACA,OACA,WAC2B;CAC3B,MAAM,EAAE,MAAM,YAAY;CAG1B,MAAM,eAAe,oBAAoB,WAAW,MAAM,QAAQ;AAClE,KAAI,aAAa,SAAS,EAExB,QAAO;EACL;EACA,WAAW;EACX,WAAW;EACX,iBAAiB;EACjB;EACD;CAIH,MAAM,YAAY,MAAM,UAAU,SAAS,KAAK;AAEhD,QAAO;EACL;EACA;EACA,WAAW,YAAY;EACvB,iBAAiB;EACjB,cAAc,EAAE;EACjB;;;;;;;;;;AAWH,eAAsB,UACpB,WACA,OACA,SACuB;CACvB,MAAM,EAAE,cAAc;CAEtB,MAAMC,cAAkC,EAAE;AAI1C,MAAK,MAAM,SAAS,OAAO;EACzB,MAAM,SAAS,MAAM,WAAW,WAAW,OAAO,UAAU;AAC5D,cAAY,KAAK,OAAO;;CAI1B,MAAM,eAAe,YAAY,QAAQ,MAAM,EAAE,UAAU,CAAC;CAC5D,MAAM,mBAAmB,YAAY,QAAQ,MAAM,EAAE,gBAAgB,CAAC;CACtE,MAAM,oBAAoB,YAAY,QAAQ,KAAK,MAAM,MAAM,EAAE,aAAa,QAAQ,EAAE;AAExF,QAAO;EACL,gBAAgB,MAAM;EACtB;EACA;EACA;EACA;EACD"}

package/dist/commands/query.d.ts

@@ -0,0 +1,152 @@
+import { Workspace } from "../model/workspace.js";
+import { Query, QueryCondition, parseQueryString } from "../services/query.js";
+import { ChangeTracker } from "../services/change-tracker/change-tracker.js";
+
+//#region src/commands/query.d.ts
+
+/**
+ * Information about a condition in a query.
+ */
+interface QueryConditionInfo {
+  kind: QueryCondition["kind"];
+  /** For field conditions */
+  field?: string;
+  value?: string;
+  /** For tag conditions */
+  tag?: string;
+  /** For link conditions */
+  link?: string;
+}
+/**
+ * Information about an entry that matched a query.
+ */
+interface QueryEntryInfo {
+  /** File path containing the entry */
+  file: string;
+  /** Formatted timestamp string */
+  timestamp: string;
+  /** Entity type (e.g., "lore", "opinion") */
+  entity: string;
+  /** Entry title */
+  title: string;
+  /** Link ID if present */
+  linkId: string | null;
+  /** Tags on the entry */
+  tags: string[];
+  /** 1-based start line */
+  startLine: number;
+  /** 1-based end line */
+  endLine: number;
+  /** Raw source text of the entry (optional, for "raw" format) */
+  rawText?: string;
+}
+/**
+ * Result of running the query command (single query).
+ */
+interface QueryResult {
+  /** The parsed query */
+  query: Query;
+  /** Formatted query string for display */
+  queryString: string;
+  /** Matching entries */
+  entries: QueryEntryInfo[];
+  /** Total count (may be more than entries.length if limited) */
+  totalCount: number;
+}
+/**
+ * Result of running queries (multiple queries).
+ */
+interface QueriesResult {
+  /** The parsed queries */
+  queries: Query[];
+  /** Formatted query string for display */
+  queryString: string;
+  /** Matching entries (deduplicated across all queries) */
+  entries: QueryEntryInfo[];
+  /** Total count (may be more than entries.length if limited) */
+  totalCount: number;
+}
+/**
+ * Error result when queries reference unknown entities.
+ */
+interface QueryValidationError {
+  kind: "unknown-entities";
+  /** The unknown entity names */
+  entities: string[];
+  /** Human-readable error message */
+  message: string;
+}
+/**
+ * Options for running the query command.
+ */
+interface RunQueryOptions {
+  /** Maximum number of results to return */
+  limit?: number;
+  /** Include raw source text in results */
+  includeRawText?: boolean;
+  /** Whether to validate that queried entities exist (default: true) */
+  validateEntities?: boolean;
+  /**
+   * Only return entries since this checkpoint.
+   * Format: "ts:2026-01-10T15:00Z" for timestamp-based filtering.
+   * Format: "git:abc123" for git-based filtering (requires tracker option).
+   */
+  since?: string;
+  /**
+   * Change tracker for git-based filtering.
+   * Required when using git checkpoints (git:...).
+   */
+  tracker?: ChangeTracker;
+}
+/**
+ * Error result when a checkpoint is invalid or missing required options.
+ */
+interface CheckpointError {
+  kind: "invalid-checkpoint";
+  /** Human-readable error message */
+  message: string;
+}
+/**
+ * Run multiple queries on a workspace.
+ * Supports comma-separated query syntax like "lore, journal where #career".
+ *
+ * @param workspace - The workspace to query
+ * @param queryString - The query string to parse and execute (may contain multiple queries)
+ * @param options - Query options
+ * @returns Structured query results, validation error, checkpoint error, or null if query syntax is invalid
+ */
+declare function runQueries(workspace: Workspace, queryString: string, options?: RunQueryOptions): Promise<QueriesResult | QueryValidationError | CheckpointError | null>;
+/**
+ * Run the query command on a workspace.
+ * For backward compatibility, this only supports a single query.
+ * Use `runQueries` for multiple queries or comma-separated syntax.
+ *
+ * @param workspace - The workspace to query
+ * @param queryString - The query string to parse and execute
+ * @param options - Query options
+ * @returns Structured query results, validation error, checkpoint error, or null if query is invalid
+ */
+declare function runQuery(workspace: Workspace, queryString: string, options?: RunQueryOptions): Promise<QueryResult | QueryValidationError | CheckpointError | null>;
+/**
+ * Type guard to check if a query result is a validation error.
+ */
+declare function isQueryValidationError(result: QueryResult | QueriesResult | QueryValidationError | CheckpointError | null): result is QueryValidationError;
+/**
+ * Type guard to check if a query result is a checkpoint error.
+ */
+declare function isCheckpointError(result: QueryResult | QueriesResult | QueryValidationError | CheckpointError | null): result is CheckpointError;
+/**
+ * Type guard to check if a query result is any error type.
+ */
+declare function isQueryError(result: QueryResult | QueriesResult | QueryValidationError | CheckpointError | null): result is QueryValidationError | CheckpointError;
+/**
+ * Type guard to check if a query result is a successful result (not an error).
+ */
+declare function isQuerySuccess(result: QueryResult | QueryValidationError | CheckpointError | null): result is QueryResult;
+/**
+ * Type guard to check if a queries result is a successful result (not an error).
+ */
+declare function isQueriesSuccess(result: QueriesResult | QueryValidationError | CheckpointError | null): result is QueriesResult;
+//#endregion
+export { CheckpointError, QueriesResult, QueryConditionInfo, QueryEntryInfo, QueryResult, QueryValidationError, RunQueryOptions, isCheckpointError, isQueriesSuccess, isQueryError, isQuerySuccess, isQueryValidationError, parseQueryString, runQueries, runQuery };
+//# sourceMappingURL=query.d.ts.map

package/dist/commands/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","names":[],"sources":["../../src/commands/query.ts"],"sourcesContent":[],"mappings":";;;;;;AAoFA;AAcA;AAcA;AAWiB,UA7EA,kBAAA,CA8FL;EAMK,IAAA,EAnGT,cAmGwB,CAAA,MAAA,CAAA;EA6CV;EACT,KAAA,CAAA,EAAA,MAAA;EAEF,KAAA,CAAA,EAAA,MAAA;EACA;EAAgB,GAAA,CAAA,EAAA,MAAA;EAAuB;EAA/C,IAAA,CAAA,EAAA,MAAA;;AA2FH;;;AAIW,UAtOM,cAAA,CAsON;EAAc;EAAuB,IAAA,EAAA,MAAA;EAA7C;EAAO,SAAA,EAAA,MAAA;EAyBM;EACN,MAAA,EAAA,MAAA;EAAc;EAAgB,KAAA,EAAA,MAAA;EAAuB;EAClD,MAAA,EAAA,MAAA,GAAA,IAAA;EAAoB;EAOjB,IAAA,EAAA,MAAA,EAAA;EACN;EAAc,SAAA,EAAA,MAAA;EAAgB;EAAuB,OAAA,EAAA,MAAA;EAClD;EAAe,OAAA,CAAA,EAAA,MAAA;AAO5B;;;;AAC+D,UA1P9C,WAAA,CA0P8C;EAClD;EAAuB,KAAA,EAzP3B,KAyP2B;EAAe;EAOnC,WAAA,EAAA,MAAc;EACpB;EAAc,OAAA,EA7Pb,cA6Pa,EAAA;EAAuB;EAClC,UAAA,EAAA,MAAA;;AAOb;;;AACiD,UA9PhC,aAAA,CA8PgC;EACpC;EAAa,OAAA,EA7Pf,KA6Pe,EAAA;;;;WAzPf;;;;;;;UAQM,oBAAA;;;;;;;;;;UAWA,eAAA;;;;;;;;;;;;;;;;;YAiBL;;;;;UAMK,eAAA;;;;;;;;;;;;;;iBA6CK,UAAA,YACT,0CAEF,kBACR,QAAQ,gBAAgB,uBAAuB;;;;;;;;;;;iBA2F5B,QAAA,YACT,0CAEF,kBACR,QAAQ,cAAc,uBAAuB;;;;iBAyBhC,sBAAA,SACN,cAAc,gBAAgB,uBAAuB,mCAClD;;;;iBAOG,iBAAA,SACN,cAAc,gBAAgB,uBAAuB,mCAClD;;;;iBAOG,YAAA,SACN,cAAc,gBAAgB,uBAAuB,mCAClD,uBAAuB;;;;iBAOpB,cAAA,SACN,cAAc,uBAAuB,mCAClC;;;;iBAOG,gBAAA,SACN,gBAAgB,uBAAuB,mCACpC"}

package/dist/commands/query.js

@@ -0,0 +1,151 @@
+import { executeQueries, formatQuery, parseQueryString, validateQueryEntities } from "../services/query.js";
+import { parseCheckpoint } from "../services/change-tracker/change-tracker.js";
+import { formatTimestamp } from "../formatters.js";
+import { findEntryFile, getEntrySourceText } from "../services/synthesis.js";
+
+//#region src/commands/query.ts
+/**
+* Convert a timestamp to epoch milliseconds for correct comparison across timezones
+*/
+function timestampToEpoch(ts) {
+	const isoStr = formatTimestamp(ts);
+	return Date.parse(isoStr);
+}
+/**
+* Parse an ISO timestamp string to epoch milliseconds
+*/
+function parseTimestampToEpoch(isoStr) {
+	return Date.parse(isoStr);
+}
+/**
+* Convert an InstanceEntry to QueryEntryInfo.
+*/
+function toQueryEntryInfo(entry, file, workspace, includeRawText) {
+	const info = {
+		file,
+		timestamp: formatTimestamp(entry.header.timestamp),
+		entity: entry.header.entity,
+		title: entry.header.title.value,
+		linkId: entry.header.link?.id ?? null,
+		tags: entry.header.tags.map((t) => t.name),
+		startLine: entry.location.startPosition.row + 1,
+		endLine: entry.location.endPosition.row + 1
+	};
+	if (includeRawText) {
+		const model = workspace.getModel(file);
+		if (model) info.rawText = getEntrySourceText(entry, model.source);
+	}
+	return info;
+}
+/**
+* Run multiple queries on a workspace.
+* Supports comma-separated query syntax like "lore, journal where #career".
+*
+* @param workspace - The workspace to query
+* @param queryString - The query string to parse and execute (may contain multiple queries)
+* @param options - Query options
+* @returns Structured query results, validation error, checkpoint error, or null if query syntax is invalid
+*/
+async function runQueries(workspace, queryString, options = {}) {
+	const { limit, includeRawText = false, validateEntities = true, since, tracker } = options;
+	let sinceMarker = null;
+	if (since) {
+		sinceMarker = parseCheckpoint(since);
+		if (!sinceMarker) return {
+			kind: "invalid-checkpoint",
+			message: `Invalid checkpoint format: '${since}'. Use 'ts:2026-01-10T15:00Z' for timestamps or 'git:abc123' for git commits.`
+		};
+		if (sinceMarker.type === "git" && !tracker) return {
+			kind: "invalid-checkpoint",
+			message: `Git checkpoints require a change tracker. Provide a tracker option or use timestamp checkpoints (ts:...).`
+		};
+	}
+	const queries = parseQueryString(queryString);
+	if (!queries) return null;
+	if (validateEntities) {
+		const unknownEntities = validateQueryEntities(workspace, queries);
+		if (unknownEntities.length > 0) return {
+			kind: "unknown-entities",
+			entities: unknownEntities,
+			message: `Unknown entity type${unknownEntities.length > 1 ? "s" : ""}: ${unknownEntities.map((e) => `'${e}'`).join(", ")}. Define ${unknownEntities.length > 1 ? "them" : "it"} using 'define-entity'.`
+		};
+	}
+	let results;
+	if (sinceMarker?.type === "git" && tracker) results = (await tracker.getChangedEntries(workspace, queries, sinceMarker)).entries;
+	else {
+		results = executeQueries(workspace, queries);
+		if (sinceMarker?.type === "ts") {
+			const sinceEpoch = parseTimestampToEpoch(sinceMarker.value);
+			results = results.filter((entry) => {
+				return timestampToEpoch(entry.header.timestamp) > sinceEpoch;
+			});
+		}
+	}
+	const entries = [];
+	const limitedResults = limit && limit > 0 ? results.slice(0, limit) : results;
+	for (const entry of limitedResults) {
+		const file = findEntryFile(workspace, entry);
+		if (file) entries.push(toQueryEntryInfo(entry, file, workspace, includeRawText));
+	}
+	return {
+		queries,
+		queryString: queries.map(formatQuery).join(", "),
+		entries,
+		totalCount: results.length
+	};
+}
+/**
+* Run the query command on a workspace.
+* For backward compatibility, this only supports a single query.
+* Use `runQueries` for multiple queries or comma-separated syntax.
+*
+* @param workspace - The workspace to query
+* @param queryString - The query string to parse and execute
+* @param options - Query options
+* @returns Structured query results, validation error, checkpoint error, or null if query is invalid
+*/
+async function runQuery(workspace, queryString, options = {}) {
+	const result = await runQueries(workspace, queryString, options);
+	if (!result) return null;
+	if ("kind" in result) return result;
+	return {
+		query: result.queries[0],
+		queryString: result.queryString,
+		entries: result.entries,
+		totalCount: result.totalCount
+	};
+}
+/**
+* Type guard to check if a query result is a validation error.
+*/
+function isQueryValidationError(result) {
+	return result !== null && "kind" in result && result.kind === "unknown-entities";
+}
+/**
+* Type guard to check if a query result is a checkpoint error.
+*/
+function isCheckpointError(result) {
+	return result !== null && "kind" in result && result.kind === "invalid-checkpoint";
+}
+/**
+* Type guard to check if a query result is any error type.
+*/
+function isQueryError(result) {
+	return result !== null && "kind" in result;
+}
+/**
+* Type guard to check if a query result is a successful result (not an error).
+*/
+function isQuerySuccess(result) {
+	return result !== null && !("kind" in result);
+}
+/**
+* Type guard to check if a queries result is a successful result (not an error).
+*/
+function isQueriesSuccess(result) {
+	return result !== null && !("kind" in result);
+}
+
+//#endregion
+export { isCheckpointError, isQueriesSuccess, isQueryError, isQuerySuccess, isQueryValidationError, parseQueryString, runQueries, runQuery };
+//# sourceMappingURL=query.js.map